package my.core.repetition.stringlists;

/**
 * Created with IntelliJ IDEA.
 * User: makstitoff
 * Date: 29.01.13
 * Time: 17:29
 * To change this template use File | Settings | File Templates. DELPHI_API(getDelphiApi()),
 */
public enum InterviewQuestions implements StringTypeInterface {

    JUNIOR_JAVA_WEB_DESKTOP(getJuniorJavaWebDesktop()), JUNIOR_ANDROID(getJuniorAndroid()),
    INTERMEDIATE_JAVA_DESKTOP(getIntermediateJavaDesktop()),
    INTERMEDIATE_JAVA_WEB_DESKTOP(getIntermediateJavaWebDesktop()),
    INTERMEDIATE_JAVA_WEB_DESKTOP_ANDROID(getIntermediateJavaWebDesktopAndroid()),
    SENIOR_JAVA_WEB_DESKTOP(getSeniorJavaWebDesktop());

    InterviewQuestions(String[] list) {
        this.list = list;
    }

    private String[] list;

    @Override
    public String[] getList() {
        return list;
    }

    public static String[] getJuniorJavaWebDesktop() {
        return StringListHolder.juniorJavaWebDesktop;
    }

    public static String[] getJuniorAndroid() {
        return StringListHolder.juniorAndroid;
    }

    public static String[] getIntermediateJavaDesktop() {
        return StringListHolder.intermediateJavaDesktop;
    }

    public static String[] getIntermediateJavaWebDesktop() {
        return StringListHolder.intermediateJavaWebDesktop;
    }

    public static String[] getIntermediateJavaWebDesktopAndroid() {
        return StringListHolder.intermediateJavaWebDesktopAndroid;
    }

    public static String[] getSeniorJavaWebDesktop() {
        return StringListHolder.seniorJavaWebDesktop;
    }

    private static class StringListHolder {

        /**
         * 0 - 2 years
         */
        public static String[] juniorJavaWebDesktop = {
                "cJava:Declare Classes: Source file declaration",
                "cJava:Declare Classes: Class declarations and modifiers",
                "cJava:Declare interfaces: Declare interfaces",
                "cJava:Declare class members: Access modifiers",
                "cJava:Declare class members: Constructor declarations",
                "cJava: If and switch statements",
                "cJava:Loops and Iterators: while, do and for loops",
                "cJava:Loops and Iterators: break and continue",
                "cJava:Handling exceptions: using try and catch",
                "cJava:Handling exceptions: using finally",
                "cJava:Handling exceptions: propagating uncaught exception",
                "cJava:Handling exceptions: common exception types (checked and unchecked)",
                "aOOP && OOD:Basic OOP concepts: polymorphism",
                "aOOP && OOD:Basic OOP concepts: inheritance",
                "aOOP && OOD:Basic OOP concepts: incapsulation",
                "aDesign - OOD: Abstraction",
                "aDesign - OOD: Encapsulation",
                "aDesign - OOD: Inheritance vs. Aggregation",
                "aDesign - OOD: Modularity",
                "aDesign - OOD: Polymorphism",
                "aDesign - OOD: Types vs. Classes",
                "aDesign - OOD: Abstraction Qualities (cohesion, coupling, etc)",
                "aDesign - OOD: Separation of concerns principle",
                "aDesign - OOD: Single responsibility principle",
                "bDesign - DB Design: Relational terminology: Entities",
                "bDesign - DB Design: Relational terminology: Attributes",
                "bDesign - DB Design: Relational terminology: Records (Tuples)",
                "bDesign - DB Design: Relationships (One-to-One, One-to-Many)",
                "bDesign - DB Design: Understanding ER notation",
                "bDesign - DB Design: Understanding normalization concept",
                "bDesign - DB Design: Data Integrity",
                "cConstruction - Language - Java: Identifiers & JavaBeans",
                "cConstruction - Language - Java: Declare Classes",
                "cConstruction - Language - Java: Declare Interfaces",
                "cConstruction - Language - Java: Declare Class Members",
                "cConstruction - Language - Java: Reference Variable Casting",
                "cConstruction - Language - Java: Implementing an Interface",
                "cConstruction - Language - Java: Legal Return Types",
                "cConstruction - Language - Java: Constructors and Instantiation",
                "cConstruction - Language - Java: Statics",
                "cConstruction - Language - Java: Stack and Heap",
                "cConstruction - Language - Java: Literals, Assignments, and Variables",
                "cConstruction - Language - Java: Passing Variables into Methods",
                "cConstruction - Language - Java: Array Declaration, Construction, and Initialization",
                "cConstruction - Language - Java: Java Operators",
                "cConstruction - Language - Java: if and switch Statements",
                "cConstruction - Language - Java: Loops and Iterators",
                "cConstruction - Language - Java: Handling Exceptions",
                "cConstruction - Language - Java: Common Exceptions and Errors",
                "cConstruction - Language - Java: String, StringBuilder, and StringBuffer",
                "cConstruction - Language - Java: Using the javac and java Commands",
                "cConstruction - Language - Java:Java7 features: String literals in switch statements",
                "cConstruction - Language - Java:Java7 features: Underscores in literals to improve code readability",
                "cConstruction - Language - Java:Java7 features: try-with-resources block and exception handling",
                "cConstruction - Language - Java:Java7 features: Catching multiple exception types",
                "cConstruction - Language - Java:Java7 features: Rethrowing exceptions in Java 7",
                "cConstruction - Language - Java:Java7 features: Using the diamond operator for constructor type inference",
                "cConstruction - Language - Java:Java7 features: Using the @SafeVarargs annotation",
                "iConstruction - Desktop applications - Java: Getting Started with Swing",
                "iConstruction - Desktop applications - Java: Learning Swing with the NetBeans IDE",
                "iConstruction - Desktop applications - Java: Using Swing Components",
                "iConstruction - Desktop applications - Java: Concurrency in Swing",
                "iConstruction - Desktop applications - Java: Laying Out Components Within a Container",
                "iConstruction - Desktop applications - Java: Writing Event Listeners",
                "jConstruction - SQL: Tables, relationships, keys, constraints understanding",
                "jConstruction - SQL: DDL, DML, DCL understanding",
                "jConstruction - SQL: SQL data types ",
                "jConstruction - SQL: SQL operators, functions",
                "jConstruction - SQL: Data manipulation (insert, update, delete)",
                "jConstruction - SQL: Retrieving data (simple select statement)",
                "jConstruction - SQL: Joins understanding",
                "kConstruction - DB Access - Java: Processing SQL Statements with JDBC:Establishing a Connection, Using Statements and Prepared Statements, Retrieving and Modifying Values from Result Sets, Using Transactions",
                "kConstruction - DB Access - Java: Understanding object/relational mapping concepts",
                "kConstruction - DB Access - Java: JPA: EntityManager, Persistence Context, Persistence Unit and EntityManagerFactory concepts",
                "kConstruction - DB Access - Java:JPA Object-Relational Mapping: Annotations for Object/Relational Mapping",
                "kConstruction - DB Access - Java:JPA Object-Relational Mapping: Mapping to a Table",
                "kConstruction - DB Access - Java:JPA Object-Relational Mapping: Mapping Simple Types",
                "kConstruction - DB Access - Java:JPA Object-Relational Mapping: Mapping the Primary Key",
                "kConstruction - DB Access - Java:JPA Object-Relational Mapping: Mapping Relationships (Unidirectional, Bidirectional, Many-to-One, One-to-One, Many-to-Many)",
                "kConstruction - DB Access - Java:JPA Object-Relational Mapping: Embedded Objects",
                "kConstruction - DB Access - Java:JPA Object-Relational Mapping: Collection Mapping",
                "kConstruction - DB Access - Java:Entity Operations basics: Entity Instance Creation",
                "kConstruction - DB Access - Java:Entity Operations basics: Persisting an Entity Instance",
                "kConstruction - DB Access - Java:Entity Operations basics: Entity removal",
                "lVerification - Code Quality - Java: Code Conventions for the Java Programming Language",
                "mVerification - Automated Testing - Java: JUnit fundamentals and elementary tests",
                "nConfiguration Management - Builds: Automated build concept",
                "nConfiguration Management - Builds: Building with build tool (ant, make, rake, ...), cleaning up built product",
                "oConfiguration Management: VCS (Version Control Systems): Fundamental concepts: revisions, working copy, repository",
                "oConfiguration Management: VCS (Version Control Systems): Getting (checking out) data from repository",
                "oConfiguration Management: VCS (Version Control Systems): Examining local changes, comparing working copy to repository",
                "oConfiguration Management: VCS (Version Control Systems): Updating working copy, merging changes",
                "oConfiguration Management: VCS (Version Control Systems): Updating to specific version",
                "oConfiguration Management: VCS (Version Control Systems): Examining change history",
                "oConfiguration Management: VCS (Version Control Systems): Discarding changes",
                "oConfiguration Management: VCS (Version Control Systems): Resolving conflicts in code",
                "oConfiguration Management: VCS (Version Control Systems): Copying, moving files, folders in repository",
                "oConfiguration Management: VCS (Version Control Systems): Committing changes",
                "oConfiguration Management: VCS (Version Control Systems): Creating, discovering and breaking locks (if supported)",
                "dConstruction - Web UI:JavaScript: Variables",
                "dConstruction - Web UI:Javascript: Data types and types conversion",
                "dConstruction - Web UI:Javascript: Operators",
                "dConstruction - Web UI:Javascript: Control and Loop constructions",
                "dConstruction - Web UI:Javascript: Functions and Variables scopes",
                "dConstruction - Web UI:Javascript: Arrays",
                "dConstruction - Web UI:Javascript: Event Handling",
                "dConstruction - Web UI:DOM: Locating and modifying elements",
                "dConstruction - Web UI:HTML: Basic elements",
                "dConstruction - Web UI:CSS: Simple Style rules",
                "eConstruction - Web server applications - Java:An Overview of Servlet and JSP Technology",
                "eConstruction - Web server applications - Java:Server Setup and Configuration",
                "eConstruction - Web server applications - Java:Servlet Basics",
                "eConstruction - Web server applications - Java:Handling the Client Request: Form Data",
                "eConstruction - Web server applications - Java:Invoking Java Code with JSP Scripting Elements",
                "eConstruction - Web server applications - Java:Session Tracking",
                "eConstruction - Web server applications - Java:Integrating Servlets and JSP: The Model View Controller (MVC) Architecture",
                "eConstruction - Web server applications - Java:XML Basics",
                "eConstruction - Web server applications - Java:The W3C XML Schema Language",
                "eConstruction - Web server applications - Java:Handling the Client Request: HTTP Request Headers",
                "eConstruction - Web server applications - Java:Generating the Server Response: HTTP Status Codes",
                "eConstruction - Web server applications - Java:Generating the Server Response: HTTP Response Headers Topics in This Chapter",
                "eConstruction - Web server applications - Java:Handling Cookies",
                "eConstruction - Web server applications - Java:JAXP: SAX2 / DOM",
                "fConstruction - Java Enterprise Essentials:JEE platform components",
                "fConstruction - Java Enterprise Essentials:Java Application Server (one of: Tomcat/JBoss/Glassfish/etc):start/stop AS",
                "fConstruction - Java Enterprise Essentials:Java Application Server (one of: Tomcat/JBoss/Glassfish/etc):Deploy/Undeploy application",
                "fConstruction - Java Enterprise Essentials:Java Application Server (one of: Tomcat/JBoss/Glassfish/etc):Monitor app state: console/logs",
                "fConstruction - Java Enterprise Essentials:Manifest file",
                "fConstruction - Java Enterprise Essentials:Deployment packaging (ear, war, jar)",
                "fConstruction - Java Enterprise Essentials:Dependency Injection (aka DI): injection points (Java EE/Spring)",
                "fConstruction - Java Enterprise Essentials:Bean validation: concept, buld-in constraints",
                "fConstruction - Java Enterprise Essentials:DI containers (Spring/Google Guice/EJB3): concepts",
                "fConstruction - Java Enterprise Essentials:EJB:EJB component types",
                "fConstruction - Java Enterprise Essentials:EJB:Container services",
                "fConstruction - Java Enterprise Essentials:Spring:Spring building blocks",
                "fConstruction - Java Enterprise Essentials:Spring:IoC and DI in Spring",
                "gConstruction - Spring MVC - Java:DispatcherServlet Processing Sequence",
                "gConstruction - Spring MVC - Java:Spring MVC architecture diagram",
                "gConstruction - Spring MVC - Java:Request flow in Spring MVC",
                "gConstruction - Spring MVC - Java:Spring: Create and configure your own Controller",
                "hConstruction - JSF:JSF configuration and life cycle",
                "hConstruction - JSF:Running Sample App",
                "hConstruction - JSF:Basic Structure of Facelet Pages and Managed Beans",
                "hConstruction - JSF:faces-config.xml (navigation rules and bean declaration)",
                "hConstruction - JSF:JSF HTML Tags",
                "hConstruction - JSF:Basic form validation"
        };

        /**
         * 0 - 2 years
         */
        public static String[] juniorAndroid = {
                "cJava:Declare Classes: Source file declaration",
                "cJava:Declare Classes: Class declarations and modifiers",
                "cJava:Declare interfaces: Declare interfaces",
                "cJava:Declare class members: Access modifiers",
                "cJava:Declare class members: Constructor declarations",
                "cJava: If and switch statements",
                "cJava:Loops and Iterators: while, do and for loops",
                "cJava:Loops and Iterators: break and continue",
                "cJava:Handling exceptions: using try and catch",
                "cJava:Handling exceptions: using finally",
                "cJava:Handling exceptions: propagating uncaught exception",
                "cJava:Handling exceptions: common exception types (checked and unchecked)",
                "aOOP && OOD:Basic OOP concepts: polymorphism",
                "aOOP && OOD:Basic OOP concepts: inheritance",
                "aOOP && OOD:Basic OOP concepts: incapsulation",
                "aDesign - OOD: Abstraction",
                "aDesign - OOD: Encapsulation",
                "aDesign - OOD: Inheritance vs. Aggregation",
                "aDesign - OOD: Modularity",
                "aDesign - OOD: Polymorphism",
                "aDesign - OOD: Types vs. Classes",
                "aDesign - OOD: Abstraction Qualities (cohesion, coupling, etc)",
                "aDesign - OOD: Separation of concerns principle",
                "aDesign - OOD: Single responsibility principle",
                "bDesign - DB Design: Relational terminology: Entities",
                "bDesign - DB Design: Relational terminology: Attributes",
                "bDesign - DB Design: Relational terminology: Records (Tuples)",
                "bDesign - DB Design: Relationships (One-to-One, One-to-Many)",
                "bDesign - DB Design: Understanding ER notation",
                "bDesign - DB Design: Understanding normalization concept",
                "bDesign - DB Design: Data Integrity",
                "cConstruction - Language - Java: Identifiers & JavaBeans",
                "cConstruction - Language - Java: Declare Classes",
                "cConstruction - Language - Java: Declare Interfaces",
                "cConstruction - Language - Java: Declare Class Members",
                "cConstruction - Language - Java: Reference Variable Casting",
                "cConstruction - Language - Java: Implementing an Interface",
                "cConstruction - Language - Java: Legal Return Types",
                "cConstruction - Language - Java: Constructors and Instantiation",
                "cConstruction - Language - Java: Statics",
                "cConstruction - Language - Java: Stack and Heap",
                "cConstruction - Language - Java: Literals, Assignments, and Variables",
                "cConstruction - Language - Java: Passing Variables into Methods",
                "cConstruction - Language - Java: Array Declaration, Construction, and Initialization",
                "cConstruction - Language - Java: Java Operators",
                "cConstruction - Language - Java: if and switch Statements",
                "cConstruction - Language - Java: Loops and Iterators",
                "cConstruction - Language - Java: Handling Exceptions",
                "cConstruction - Language - Java: Common Exceptions and Errors",
                "cConstruction - Language - Java: String, StringBuilder, and StringBuffer",
                "cConstruction - Language - Java: Using the javac and java Commands",
                "cConstruction - Language - Java:Java7 features: String literals in switch statements",
                "cConstruction - Language - Java:Java7 features: Underscores in literals to improve code readability",
                "cConstruction - Language - Java:Java7 features: try-with-resources block and exception handling",
                "cConstruction - Language - Java:Java7 features: Catching multiple exception types",
                "cConstruction - Language - Java:Java7 features: Rethrowing exceptions in Java 7",
                "cConstruction - Language - Java:Java7 features: Using the diamond operator for constructor type inference",
                "cConstruction - Language - Java:Java7 features: Using the @SafeVarargs annotation",
                "dAndroid:Environment:Installing SDK and setting up IDE",
                "dAndroid:Environment:Android SDK tools",
                "dAndroid:Environment:Support library",
                "dAndroid:Application Components - Basics:Application Fundamentals",
                "dAndroid:Application Components - Basics:Activity, Fragment, Task",
                "dAndroid:Application Components - Basics:Service, Broadcast Receiver and Content Provider",
                "dAndroid:Application Components - Basics:Intent and Intent Filter",
                "dAndroid:Application Components - Basics:Process, Thread and Permissions",
                "dAndroid:User interface - Basics:UI Patterns and Building Blocks",
                "dAndroid:User interface - Basics:View Hierarchy and Layout",
                "dAndroid:User interface - Basics:UI Controls, UI Events",
                "dAndroid:User interface - Basics:Search",
                "dAndroid:User interface - Basics:Action Bar and Menu",
                "dAndroid:User interface - Basics:Dialog, Notification and Toast",
                "dAndroid:Application Resources:Resource Types",
                "dAndroid:Application Resources:Providing and Accessing Resources",
                "dAndroid:Application Resources:Handling Runtime Changes and Localization",
                "dAndroid:Persistence - Basics:Internal Storage",
                "dAndroid:Persistence - Basics:External Storage",
                "dAndroid:Persistence - Basics:Shared Preferences",
                "dAndroid:Networking and Web Services:Performing Network Operations",
                "jConstruction - SQL: Tables, relationships, keys, constraints understanding",
                "jConstruction - SQL: DDL, DML, DCL understanding",
                "jConstruction - SQL: SQL data types ",
                "jConstruction - SQL: SQL operators, functions",
                "jConstruction - SQL: Data manipulation (insert, update, delete)",
                "jConstruction - SQL: Retrieving data (simple select statement)",
                "jConstruction - SQL: Joins understanding",
                "kConstruction - DB Access - Java: Processing SQL Statements with JDBC:Establishing a Connection, Using Statements and Prepared Statements, Retrieving and Modifying Values from Result Sets, Using Transactions",
                "kConstruction - DB Access - Java: Understanding object/relational mapping concepts",
                "kConstruction - DB Access - Java: JPA: EntityManager, Persistence Context, Persistence Unit and EntityManagerFactory concepts",
                "kConstruction - DB Access - Java:JPA Object-Relational Mapping: Annotations for Object/Relational Mapping",
                "kConstruction - DB Access - Java:JPA Object-Relational Mapping: Mapping to a Table",
                "kConstruction - DB Access - Java:JPA Object-Relational Mapping: Mapping Simple Types",
                "kConstruction - DB Access - Java:JPA Object-Relational Mapping: Mapping the Primary Key",
                "kConstruction - DB Access - Java:JPA Object-Relational Mapping: Mapping Relationships (Unidirectional, Bidirectional, Many-to-One, One-to-One, Many-to-Many)",
                "kConstruction - DB Access - Java:JPA Object-Relational Mapping: Embedded Objects",
                "kConstruction - DB Access - Java:JPA Object-Relational Mapping: Collection Mapping",
                "kConstruction - DB Access - Java:Entity Operations basics: Entity Instance Creation",
                "kConstruction - DB Access - Java:Entity Operations basics: Persisting an Entity Instance",
                "kConstruction - DB Access - Java:Entity Operations basics: Entity removal",
                "lVerification - Code Quality - Java: Code Conventions for the Java Programming Language",
                "mVerification - Automated Testing - Java: JUnit fundamentals and elementary tests",
                "nConfiguration Management - Builds: Automated build concept",
                "nConfiguration Management - Builds: Building with build tool (ant, make, rake, ...), cleaning up built product",
                "oConfiguration Management: VCS (Version Control Systems): Fundamental concepts: revisions, working copy, repository",
                "oConfiguration Management: VCS (Version Control Systems): Getting (checking out) data from repository",
                "oConfiguration Management: VCS (Version Control Systems): Examining local changes, comparing working copy to repository",
                "oConfiguration Management: VCS (Version Control Systems): Updating working copy, merging changes",
                "oConfiguration Management: VCS (Version Control Systems): Updating to specific version",
                "oConfiguration Management: VCS (Version Control Systems): Examining change history",
                "oConfiguration Management: VCS (Version Control Systems): Discarding changes",
                "oConfiguration Management: VCS (Version Control Systems): Resolving conflicts in code",
                "oConfiguration Management: VCS (Version Control Systems): Copying, moving files, folders in repository",
                "oConfiguration Management: VCS (Version Control Systems): Committing changes",
                "oConfiguration Management: VCS (Version Control Systems): Creating, discovering and breaking locks (if supported)"
        };

        public static String[] intermediateJavaDesktop = {
                "7Java:JavaBean definition",
                "7Java:Declare interfaces:Implicit modifiers of interface members",
                "7Java:Declaring enums",
                "7Java:Overriding/Overloading",
                "7Java:Constructors and Instantiation:Order of initialization/calling of fields and constructors",
                "7Java:Constructors and Instantiation:Constructor overloading",
                "7Java:Using Wrapper classes and boxing:Intention of wrapping objects",
                "7Java:Using Wrapper classes and boxing:Creation wrapping objects",
                "7Java:Using Wrapper classes and boxing:Autoboxing",
                "7Java:Handling exceptions:exception matching and declaration",
                "7Java:Passing variables into methods",
                "7Java:String, StringBuilder and StringBuffer",
                "7Java:Overriding hashCode and equals",
                "7Java:Collections:Collection",
                "7Java:Collections:List interface",
                "7Java:Collections:Set interface",
                "7Java:Collections:Map interface",
                "7Java:Using collections API:ArrayList",
                "7Java:Using collections API:HashMap",
                "7Java:Generic types:Generics and legacy code",
                "7Java:Generic types:Generics declarations",
                "7Java:Inner classes:coding a regular inner class",
                "7Java:Anonymous inner classes",
                "7Java:Static inner classes:Instantiation and using",
                "7Java:Static inner classes:access to outer class instance fields",
                "7Java:Garbage Collection:Definition of grabage collection and garbage collector",
                "gUnit testing:Purpose of unit tests",
                "gUnit testing:JUnit 4:Setup and tear down",
                "gUnit testing:JUnit 4:Exception handling",
                "gUnit testing:JUnit 4:Asserts",
                "4OOP && OOD:Separation of concerns",
                "1Engineering Management - Process Planning (SDLC):Software development process:Software development activities",
                "1Engineering Management - Process Planning (SDLC):Basics of SDLC models:Waterfall",
                "1Engineering Management - Process Planning (SDLC):Basics of SDLC models:Spiral",
                "1Engineering Management - Process Planning (SDLC):Basics of SDLC models:Incremental development",
                "1Engineering Management - Process Planning (SDLC):Basics of SDLC models:Agile development",
                "1Engineering Management - Process Planning (SDLC):Basics of SDLC models:Prototyping",
                "1Engineering Management - Process Planning (SDLC):Basics of SDLC models:Rapid Application Development",
                "1Engineering Management - Process Planning (SDLC):Basics of SDLC models:Lean software development",
                "1Engineering Management - Process Planning (SDLC):Scrum:Roles and responsibilities",
                "1Engineering Management - Process Planning (SDLC):Scrum:Artifacts",
                "1Engineering Management - Process Planning (SDLC):Scrum:Flow",
                "1Engineering Management - Process Planning (SDLC):Scrum:Ceremonies",
                "2Engineering Management - Estimation:Scope Concept",
                "2Engineering Management - Estimation:Estimates, Targets, and Commitments ",
                "2Engineering Management - Estimation:Overestimate vs Underestimate ",
                "2Engineering Management - Estimation:Decomposition and Recomposition ",
                "2Engineering Management - Estimation:Analogy-based estimations ",
                "2Engineering Management - Estimation:Story based estimations ",
                "3Requirements - Software Requirements:Requirement definition ",
                "3Requirements - Software Requirements:Levels of Requirements: Business, User, and Functional requirements Most common requirements risks Characteristics of Excellent Requirements Benefits from a High-Quality Requirements Process ",
                "3Requirements - Software Requirements:Root Causes of Project Success and Failure",
                "3Requirements - Software Requirements:Sources of Requirements ",
                "3Requirements - Software Requirements:Basic Requirements Elicitation Techniques:Brainstorming",
                "3Requirements - Software Requirements:Basic Requirements Elicitation Techniques:Interviews",
                "3Requirements - Software Requirements:Basic Requirements Elicitation Techniques:Survey/ Questionnaire",
                "3Requirements - Software Requirements:Basic Requirements Elicitation Techniques:Document Analysis",
                "3Requirements - Software Requirements:Requirements artifacts - SRS (according to IEEE Standard 830-1998)",
                "4Design - OOD:GoF Design Patterns",
                "4Design - OOD:Architectural Patterns: Layered Architecture",
                "4Design - OOD:Architectural Patterns: MVC",
                "4Design - OOD:Architectural Patterns: SOA and EDA",
                "4Design - OOD:Architectural Patterns: IoC",
                "4Design - OOD:SOLID principles",
                "4Design - OOD:Anti-patterns",
                "5Design - DB Design: Relational terminology: Entities",
                "5Design - DB Design: Relational terminology: Attributes",
                "5Design - DB Design: Relational terminology: Records (Tuples)",
                "5Design - DB Design: Relationships (One-to-One, One-to-Many)",
                "5Design - DB Design: Understanding ER notation",
                "5Design - DB Design: Understanding normalization concept",
                "5Design - DB Design: Data Integrity",
                "6Design - Modeling:UML: Basic Diagram Types",
                "6Design - Modeling:UML: Use Case Diagram (Essentials)",
                "6Design - Modeling:UML: Class Diagram (Essentials)",
                "6Design - Modeling:Entity Relationship Diagrams",
                "6Design - Modeling:Data Flow Diagrams",
                "7Construction - Language - Java:Using Wrapper Classes and Boxing",
                "7Construction - Language - Java:Overloading",
                "7Construction - Language - Java:Garbage Collection",
                "7Construction - Language - Java:Working with the Assertion Mechanism",
                "7Construction - Language - Java:File Navigation and I/O",
                "7Construction - Language - Java:Dates, Numbers, and Currency",
                "7Construction - Language - Java:Parsing,Tokenizing, and Formatting",
                "7Construction - Language - Java:Overriding hashCode() and equals()",
                "7Construction - Language - Java:Collections",
                "7Construction - Language - Java:Using the Collections Framework",
                "7Construction - Language - Java:Generic Types",
                "7Construction - Language - Java:JAR Files",
                "7Construction - Language - Java:Static Imports",
                "7Construction - Language - Java:Serialization",
                "7Construction - Language - Java:Inner Classes",
                "7Construction - Language - Java:Method-Local Inner Classes",
                "7Construction - Language - Java:Anonymous Inner Classes",
                "7Construction - Language - Java:Static Nested Classes",
                "7Construction - Language - Java:Reflection",
                "7Construction - Language - Java:Annotations",
                "7Construction - Language - Java:Java 7 features:Locating Files and Directories Using Paths",
                "7Construction - Language - Java:Java 7 features:Obtaining and Managing Files and Directories",
                "7Construction - Language - Java:Java 7 features:Working with Filesystems in Java 7",
                "7Construction - Language - Java:Java 7 features:Stream IO in Java 7",
                "8Construction - Refactoring:Refactoring Concept (what/when/why)",
                "8Construction - Refactoring:Smells Catalog and possible re-factorings",
                "8Construction - Refactoring:Moving Features Between Objects (basic):Move Method",
                "8Construction - Refactoring:Moving Features Between Objects (basic):Move Field",
                "8Construction - Refactoring:Organizing Data (basic):Encapsulate Field",
                "8Construction - Refactoring:Organizing Data (basic):Encapsulate Collection",
                "8Construction - Refactoring:Composing Methods (basic):Extract Method",
                "8Construction - Refactoring:Composing Methods (basic):Inline Method",
                "8Construction - Refactoring:Composing Methods (basic):Inline Temp",
                "8Construction - Refactoring:Composing Methods (basic):Replace Temp with Query",
                "8Construction - Refactoring:Composing Methods (basic):Split Temporary Variable",
                "8Construction - Refactoring:Simplifying Conditional Expressions (basic):Decompose Conditional Expression",
                "8Construction - Refactoring:Simplifying Conditional Expressions (basic):Consolidate Conditional Expression",
                "8Construction - Refactoring:Simplifying Conditional Expressions (basic):Consolidate Duplicate Conditional Fragments",
                "8Construction - Refactoring:Simplifying Conditional Expressions (basic):Remove Control Flag",
                "8Construction - Refactoring:Simplifying Conditional Expressions (basic):Replace Conditional with Polymorphism",
                "9Construction - Concurrency - Java:Defining, Instantiating, and Starting Threads",
                "9Construction - Concurrency - Java:Thread States and Transitions",
                "9Construction - Concurrency - Java:Thread Interaction",
                "9Construction - Concurrency - Java:Synchronizing Code with synchronized keyword",
                "9Construction - Concurrency - Java:The Volatile Keyword",
                "9Construction - Concurrency - Java:Race conditions",
                "9Construction - Concurrency - Java:Nested Locks in Java",
                "9Construction - Concurrency - Java:Using wait(), notify(), and notifyAll() for synchronization",
                "9Construction - Concurrency - Java:Using of conditional variables for synchronization",
                "aConstruction - Networking - Java:The Layers of a Network",
                "aConstruction - Networking - Java:Application Layer Protocols Basics",
                "aConstruction - Networking - Java:Understanding Networks - Layers and Protocols",
                "aConstruction - Networking - Java:IP, TCP, and UDP",
                "aConstruction - Networking - Java:The Client/Server Model",
                "aConstruction - Networking - Java:Internet Standards",
                "aConstruction - Networking - Java:HTML, SGML, and XML",
                "aConstruction - Networking - Java:HTTP",
                "aConstruction - Networking - Java:MIME Media Types",
                "aConstruction - Networking - Java:Looking Up Internet Addresses",
                "aConstruction - Networking - Java:URLs and URIs",
                "aConstruction - Networking - Java:Sockets for Clients",
                "aConstruction - Networking - Java:Sockets for Servers",
                "aConstruction - Networking - Java:UDP Datagrams and Sockets",
                "aConstruction - Networking - Java:URLConnections",
                "bConstruction - Desktop applications - Java:Using Other Swing Features (actions, timers, and the system tray, etc.)",
                "bConstruction - Desktop applications - Java:Modifying the Look and Feel",
                "bConstruction - Desktop applications - Java:Drag and Drop and Data Transfer",
                "bConstruction - Desktop applications - Java:Performing Custom Painting",
                "bConstruction - Desktop applications - Java:Overview of the Java 2D API Concepts",
                "bConstruction - Desktop applications - Java:Getting Started with Graphics Working with Geometry",
                "bConstruction - Desktop applications - Java:Working with Text APIs",
                "bConstruction - Desktop applications - Java:Working with Images",
                "bConstruction - Desktop applications - Java:Printing",
                "bConstruction - Desktop applications - Java:Advanced Topics in Java2D",
                "cConstruction - SQL:Creating, modifying, removing database objects",
                "cConstruction - SQL:Aggregations (ORDER BY, GROUP BY, HAVING, SUM, COUNT, AVG, etc)",
                "cConstruction - SQL:Combining the results of multiple queries (union, except, intersect, minus, subqueries)",
                "cConstruction - SQL:Sessions, transactions, locks",
                "cConstruction - SQL:Implementing stored procedures, user-defined functions, triggers",
                "cConstruction - SQL:Cursors",
                "dConstruction - DB Access - Java: Processing SQL Statements with JDBC:Establishing a Connection, Using Statements and Prepared Statements, Retrieving and Modifying Values from Result Sets, Using Transactions",
                "dConstruction - DB Access - Java: Understanding object/relational mapping concepts",
                "dConstruction - DB Access - Java: JPA: EntityManager, Persistence Context, Persistence Unit and EntityManagerFactory concepts",
                "dConstruction - DB Access - Java:JPA Object-Relational Mapping: Annotations for Object/Relational Mapping",
                "dConstruction - DB Access - Java:JPA Object-Relational Mapping: Mapping to a Table",
                "dConstruction - DB Access - Java:JPA Object-Relational Mapping: Mapping Simple Types",
                "dConstruction - DB Access - Java:JPA Object-Relational Mapping: Mapping the Primary Key",
                "dConstruction - DB Access - Java:JPA Object-Relational Mapping: Mapping Relationships (Unidirectional, Bidirectional, Many-to-One, One-to-One, Many-to-Many)",
                "dConstruction - DB Access - Java:JPA Object-Relational Mapping: Embedded Objects",
                "dConstruction - DB Access - Java:JPA Object-Relational Mapping: Collection Mapping",
                "dConstruction - DB Access - Java:Entity Operations basics: Entity Instance Creation",
                "dConstruction - DB Access - Java:Entity Operations basics: Persisting an Entity Instance",
                "dConstruction - DB Access - Java:Entity Operations basics: Entity removal",
                "eConstruction - Big Data:Understanding MapReduce jobs",
                "eConstruction - Big Data:Hadoop architectural components, Single- and multi-node configuration, Web-based monitor tools",
                "eConstruction - Big Data:Work with HDFS",
                "eConstruction - Big Data:Map and Reduce tasks",
                "eConstruction - Big Data:Input and Output",
                "eConstruction - Big Data:Basic programming for Hadoop (using standard text input/output classes)",
                "eConstruction - Big Data:Understand difference between different MapReduce types and formats.",
                "fVerification - Code Quality - Java:Automated coding standards enforcement (Check Style)",
                "fVerification - Code Quality - Java:Code Reviews and Toolset (Jupiter)",
                "fVerification - Code Quality - Java:Preemptive Error Detection (Find Bugs, PMD)",
                "gVerification - Automated Testing - Java:Organizing and building JUnit tests",
                "gVerification - Automated Testing - Java:Managing test suites",
                "gVerification - Automated Testing - Java:Working with test data",
                "gVerification - Automated Testing - Java:Running tests",
                "gVerification - Automated Testing - Java:Reporting tests results",
                "gVerification - Automated Testing - Java:Mocks/Stubs",
                "gVerification - Automated Testing - Java:Unit and integration tests",
                "hConfiguration Management - Builds:Scripting multiphase (build, testing, deployment, …) build process",
                "hConfiguration Management - Builds:Integrating building of product installer",
                "hConfiguration Management - Builds:Generating release notes and/or other release documentation",
                "hConfiguration Management - Builds:Development of scheduled builds (night builds)",
                "hConfiguration Management - Builds:Monitoring build process",
                "hConfiguration Management - Builds:Build status reporting (notification)",
                "hConfiguration Management - Builds:Integrating deployment stage, moving product to release area",
                "hConfiguration Management - Builds:Integrating with source control, versioning, tagging, building releases ",
                "iConfiguration Management: VCS (Version Control Systems):Importing sources into repository",
                "iConfiguration Management: VCS (Version Control Systems):Exporting sources from repository",
                "iConfiguration Management: VCS (Version Control Systems):Comparing repository revisions",
                "iConfiguration Management: VCS (Version Control Systems):Creating a branch",
                "iConfiguration Management: VCS (Version Control Systems):Working with branch",
                "iConfiguration Management: VCS (Version Control Systems):Traversing branches",
                "iConfiguration Management: VCS (Version Control Systems):Common branching patterns (rebasing in Git)",
                "iConfiguration Management: VCS (Version Control Systems):Merging branches",
                "iConfiguration Management: VCS (Version Control Systems):Tagging (labeling in TFS)",
                "iConfiguration Management: VCS (Version Control Systems):Creating and applying patches (shelvesets in TFS)",
                "iConfiguration Management: VCS (Version Control Systems):Revision specifiers",
                "iConfiguration Management: VCS (Version Control Systems):Data recovery",
                "iConfiguration Management: VCS (Version Control Systems):Using external editors and merge tools",
                "iConfiguration Management: VCS (Version Control Systems):Distributed VCS (if supported):Workflows",
                "iConfiguration Management: VCS (Version Control Systems):Distributed VCS (if supported):Checking out remote branches",
                "iConfiguration Management: VCS (Version Control Systems):Distributed VCS (if supported):Integrating contributed work",
        };

        /**
         * 2 - 3 years
         */
        public static String[] intermediateJavaWebDesktop = {
                "gJava:JavaBean definition",
                "gJava:Declare interfaces:Implicit modifiers of interface members",
                "gJava:Declaring enums",
                "gJava:Overriding/Overloading",
                "gJava:Constructors and Instantiation:Order of initialization/calling of fields and constructors",
                "gJava:Constructors and Instantiation:Constructor overloading",
                "gJava:Using Wrapper classes and boxing:Intention of wrapping objects",
                "gJava:Using Wrapper classes and boxing:Creation wrapping objects",
                "gJava:Using Wrapper classes and boxing:Autoboxing",
                "gJava:Handling exceptions:exception matching and declaration",
                "gJava:Passing variables into methods",
                "gJava:String, StringBuilder and StringBuffer",
                "gJava:Overriding hashCode and equals",
                "gJava:Collections:Collection",
                "gJava:Collections:List interface",
                "gJava:Collections:Set interface",
                "gJava:Collections:Map interface",
                "gJava:Using collections API:ArrayList",
                "gJava:Using collections API:HashMap",
                "gJava:Generic types:Generics and legacy code",
                "gJava:Generic types:Generics declarations",
                "gJava:Inner classes:coding a regular inner class",
                "gJava:Anonymous inner classes",
                "gJava:Static inner classes:Instantiation and using",
                "gJava:Static inner classes:access to outer class instance fields",
                "gJava:Garbage Collection:Definition of grabage collection and garbage collector",
                "wUnit testing:Purpose of unit tests",
                "wUnit testing:JUnit 4:Setup and tear down",
                "wUnit testing:JUnit 4:Exception handling",
                "wUnit testing:JUnit 4:Asserts",
                "dOOP && OOD:Separation of concerns",
                "aEngineering Management - Process Planning (SDLC):Software development process:Software development activities",
                "aEngineering Management - Process Planning (SDLC):Basics of SDLC models:Waterfall",
                "aEngineering Management - Process Planning (SDLC):Basics of SDLC models:Spiral",
                "aEngineering Management - Process Planning (SDLC):Basics of SDLC models:Incremental development",
                "aEngineering Management - Process Planning (SDLC):Basics of SDLC models:Agile development",
                "aEngineering Management - Process Planning (SDLC):Basics of SDLC models:Prototyping",
                "aEngineering Management - Process Planning (SDLC):Basics of SDLC models:Rapid Application Development",
                "aEngineering Management - Process Planning (SDLC):Basics of SDLC models:Lean software development",
                "aEngineering Management - Process Planning (SDLC):Scrum:Roles and responsibilities",
                "aEngineering Management - Process Planning (SDLC):Scrum:Artifacts",
                "aEngineering Management - Process Planning (SDLC):Scrum:Flow",
                "aEngineering Management - Process Planning (SDLC):Scrum:Ceremonies",
                "bEngineering Management - Estimation:Scope Concept",
                "bEngineering Management - Estimation:Estimates, Targets, and Commitments ",
                "bEngineering Management - Estimation:Overestimate vs Underestimate ",
                "bEngineering Management - Estimation:Decomposition and Recomposition ",
                "bEngineering Management - Estimation:Analogy-based estimations ",
                "bEngineering Management - Estimation:Story based estimations ",
                "cRequirements - Software Requirements:Requirement definition ",
                "cRequirements - Software Requirements:Levels of Requirements: Business, User, and Functional requirements Most common requirements risks Characteristics of Excellent Requirements Benefits from a High-Quality Requirements Process ",
                "cRequirements - Software Requirements:Root Causes of Project Success and Failure",
                "cRequirements - Software Requirements:Sources of Requirements ",
                "cRequirements - Software Requirements:Basic Requirements Elicitation Techniques:Brainstorming",
                "cRequirements - Software Requirements:Basic Requirements Elicitation Techniques:Interviews",
                "cRequirements - Software Requirements:Basic Requirements Elicitation Techniques:Survey/ Questionnaire",
                "cRequirements - Software Requirements:Basic Requirements Elicitation Techniques:Document Analysis",
                "cRequirements - Software Requirements:Requirements artifacts - SRS (according to IEEE Standard 830-1998)",
                "dDesign - OOD:GoF Design Patterns",
                "dDesign - OOD:Architectural Patterns: Layered Architecture",
                "dDesign - OOD:Architectural Patterns: MVC",
                "dDesign - OOD:Architectural Patterns: SOA and EDA",
                "dDesign - OOD:Architectural Patterns: IoC",
                "dDesign - OOD:SOLID principles",
                "dDesign - OOD:Anti-patterns",
                "eDesign - DB Design: Relational terminology: Entities",
                "eDesign - DB Design: Relational terminology: Attributes",
                "eDesign - DB Design: Relational terminology: Records (Tuples)",
                "eDesign - DB Design: Relationships (One-to-One, One-to-Many)",
                "eDesign - DB Design: Understanding ER notation",
                "eDesign - DB Design: Understanding normalization concept",
                "eDesign - DB Design: Data Integrity",
                "fDesign - Modeling:UML: Basic Diagram Types",
                "fDesign - Modeling:UML: Use Case Diagram (Essentials)",
                "fDesign - Modeling:UML: Class Diagram (Essentials)",
                "fDesign - Modeling:Entity Relationship Diagrams",
                "fDesign - Modeling:Data Flow Diagrams",
                "gConstruction - Language - Java:Using Wrapper Classes and Boxing",
                "gConstruction - Language - Java:Overloading",
                "gConstruction - Language - Java:Garbage Collection",
                "gConstruction - Language - Java:Working with the Assertion Mechanism",
                "gConstruction - Language - Java:File Navigation and I/O",
                "gConstruction - Language - Java:Dates, Numbers, and Currency",
                "gConstruction - Language - Java:Parsing,Tokenizing, and Formatting",
                "gConstruction - Language - Java:Overriding hashCode() and equals()",
                "gConstruction - Language - Java:Collections",
                "gConstruction - Language - Java:Using the Collections Framework",
                "gConstruction - Language - Java:Generic Types",
                "gConstruction - Language - Java:JAR Files",
                "gConstruction - Language - Java:Static Imports",
                "gConstruction - Language - Java:Serialization",
                "gConstruction - Language - Java:Inner Classes",
                "gConstruction - Language - Java:Method-Local Inner Classes",
                "gConstruction - Language - Java:Anonymous Inner Classes",
                "gConstruction - Language - Java:Static Nested Classes",
                "gConstruction - Language - Java:Reflection",
                "gConstruction - Language - Java:Annotations",
                "gConstruction - Language - Java:Java 7 features:Locating Files and Directories Using Paths",
                "gConstruction - Language - Java:Java 7 features:Obtaining and Managing Files and Directories",
                "gConstruction - Language - Java:Java 7 features:Working with Filesystems in Java 7",
                "gConstruction - Language - Java:Java 7 features:Stream IO in Java 7",
                "hConstruction - Refactoring:Refactoring Concept (what/when/why)",
                "hConstruction - Refactoring:Smells Catalog and possible re-factorings",
                "hConstruction - Refactoring:Moving Features Between Objects (basic):Move Method",
                "hConstruction - Refactoring:Moving Features Between Objects (basic):Move Field",
                "hConstruction - Refactoring:Organizing Data (basic):Encapsulate Field",
                "hConstruction - Refactoring:Organizing Data (basic):Encapsulate Collection",
                "hConstruction - Refactoring:Composing Methods (basic):Extract Method",
                "hConstruction - Refactoring:Composing Methods (basic):Inline Method",
                "hConstruction - Refactoring:Composing Methods (basic):Inline Temp",
                "hConstruction - Refactoring:Composing Methods (basic):Replace Temp with Query",
                "hConstruction - Refactoring:Composing Methods (basic):Split Temporary Variable",
                "hConstruction - Refactoring:Simplifying Conditional Expressions (basic):Decompose Conditional Expression",
                "hConstruction - Refactoring:Simplifying Conditional Expressions (basic):Consolidate Conditional Expression",
                "hConstruction - Refactoring:Simplifying Conditional Expressions (basic):Consolidate Duplicate Conditional Fragments",
                "hConstruction - Refactoring:Simplifying Conditional Expressions (basic):Remove Control Flag",
                "hConstruction - Refactoring:Simplifying Conditional Expressions (basic):Replace Conditional with Polymorphism",
                "iConstruction - Concurrency - Java:Defining, Instantiating, and Starting Threads",
                "iConstruction - Concurrency - Java:Thread States and Transitions",
                "iConstruction - Concurrency - Java:Thread Interaction",
                "iConstruction - Concurrency - Java:Synchronizing Code with synchronized keyword",
                "iConstruction - Concurrency - Java:The Volatile Keyword",
                "iConstruction - Concurrency - Java:Race conditions",
                "iConstruction - Concurrency - Java:Nested Locks in Java",
                "iConstruction - Concurrency - Java:Using wait(), notify(), and notifyAll() for synchronization",
                "iConstruction - Concurrency - Java:Using of conditional variables for synchronization",
                "jConstruction - Networking - Java:The Layers of a Network",
                "jConstruction - Networking - Java:Application Layer Protocols Basics",
                "jConstruction - Networking - Java:Understanding Networks - Layers and Protocols",
                "jConstruction - Networking - Java:IP, TCP, and UDP",
                "jConstruction - Networking - Java:The Client/Server Model",
                "jConstruction - Networking - Java:Internet Standards",
                "jConstruction - Networking - Java:HTML, SGML, and XML",
                "jConstruction - Networking - Java:HTTP",
                "jConstruction - Networking - Java:MIME Media Types",
                "jConstruction - Networking - Java:Looking Up Internet Addresses",
                "jConstruction - Networking - Java:URLs and URIs",
                "jConstruction - Networking - Java:Sockets for Clients",
                "jConstruction - Networking - Java:Sockets for Servers",
                "jConstruction - Networking - Java:UDP Datagrams and Sockets",
                "jConstruction - Networking - Java:URLConnections",
                "rConstruction - Desktop applications - Java:Using Other Swing Features (actions, timers, and the system tray, etc.)",
                "rConstruction - Desktop applications - Java:Modifying the Look and Feel",
                "rConstruction - Desktop applications - Java:Drag and Drop and Data Transfer",
                "rConstruction - Desktop applications - Java:Performing Custom Painting",
                "rConstruction - Desktop applications - Java:Overview of the Java 2D API Concepts",
                "rConstruction - Desktop applications - Java:Getting Started with Graphics Working with Geometry",
                "rConstruction - Desktop applications - Java:Working with Text APIs",
                "rConstruction - Desktop applications - Java:Working with Images",
                "rConstruction - Desktop applications - Java:Printing",
                "rConstruction - Desktop applications - Java:Advanced Topics in Java2D",
                "sConstruction - SQL:Creating, modifying, removing database objects",
                "sConstruction - SQL:Aggregations (ORDER BY, GROUP BY, HAVING, SUM, COUNT, AVG, etc)",
                "sConstruction - SQL:Combining the results of multiple queries (union, except, intersect, minus, subqueries)",
                "sConstruction - SQL:Sessions, transactions, locks",
                "sConstruction - SQL:Implementing stored procedures, user-defined functions, triggers",
                "sConstruction - SQL:Cursors",
                "tConstruction - DB Access - Java: Processing SQL Statements with JDBC:Establishing a Connection, Using Statements and Prepared Statements, Retrieving and Modifying Values from Result Sets, Using Transactions",
                "tConstruction - DB Access - Java: Understanding object/relational mapping concepts",
                "tConstruction - DB Access - Java: JPA: EntityManager, Persistence Context, Persistence Unit and EntityManagerFactory concepts",
                "tConstruction - DB Access - Java:JPA Object-Relational Mapping: Annotations for Object/Relational Mapping",
                "tConstruction - DB Access - Java:JPA Object-Relational Mapping: Mapping to a Table",
                "tConstruction - DB Access - Java:JPA Object-Relational Mapping: Mapping Simple Types",
                "tConstruction - DB Access - Java:JPA Object-Relational Mapping: Mapping the Primary Key",
                "tConstruction - DB Access - Java:JPA Object-Relational Mapping: Mapping Relationships (Unidirectional, Bidirectional, Many-to-One, One-to-One, Many-to-Many)",
                "tConstruction - DB Access - Java:JPA Object-Relational Mapping: Embedded Objects",
                "tConstruction - DB Access - Java:JPA Object-Relational Mapping: Collection Mapping",
                "tConstruction - DB Access - Java:Entity Operations basics: Entity Instance Creation",
                "tConstruction - DB Access - Java:Entity Operations basics: Persisting an Entity Instance",
                "tConstruction - DB Access - Java:Entity Operations basics: Entity removal",
                "uConstruction - Big Data:Understanding MapReduce jobs",
                "uConstruction - Big Data:Hadoop architectural components, Single- and multi-node configuration, Web-based monitor tools",
                "uConstruction - Big Data:Work with HDFS",
                "uConstruction - Big Data:Map and Reduce tasks",
                "uConstruction - Big Data:Input and Output",
                "uConstruction - Big Data:Basic programming for Hadoop (using standard text input/output classes)",
                "uConstruction - Big Data:Understand difference between different MapReduce types and formats.",
                "vVerification - Code Quality - Java:Automated coding standards enforcement (Check Style)",
                "vVerification - Code Quality - Java:Code Reviews and Toolset (Jupiter)",
                "vVerification - Code Quality - Java:Preemptive Error Detection (Find Bugs, PMD)",
                "wVerification - Automated Testing - Java:Organizing and building JUnit tests",
                "wVerification - Automated Testing - Java:Managing test suites",
                "wVerification - Automated Testing - Java:Working with test data",
                "wVerification - Automated Testing - Java:Running tests",
                "wVerification - Automated Testing - Java:Reporting tests results",
                "wVerification - Automated Testing - Java:Mocks/Stubs",
                "wVerification - Automated Testing - Java:Unit and integration tests",
                "xConfiguration Management - Builds:Scripting multiphase (build, testing, deployment, …) build process",
                "xConfiguration Management - Builds:Integrating building of product installer",
                "xConfiguration Management - Builds:Generating release notes and/or other release documentation",
                "xConfiguration Management - Builds:Development of scheduled builds (night builds)",
                "xConfiguration Management - Builds:Monitoring build process",
                "xConfiguration Management - Builds:Build status reporting (notification)",
                "xConfiguration Management - Builds:Integrating deployment stage, moving product to release area",
                "xConfiguration Management - Builds:Integrating with source control, versioning, tagging, building releases ",
                "yConfiguration Management: VCS (Version Control Systems):Importing sources into repository",
                "yConfiguration Management: VCS (Version Control Systems):Exporting sources from repository",
                "yConfiguration Management: VCS (Version Control Systems):Comparing repository revisions",
                "yConfiguration Management: VCS (Version Control Systems):Creating a branch",
                "yConfiguration Management: VCS (Version Control Systems):Working with branch",
                "yConfiguration Management: VCS (Version Control Systems):Traversing branches",
                "yConfiguration Management: VCS (Version Control Systems):Common branching patterns (rebasing in Git)",
                "yConfiguration Management: VCS (Version Control Systems):Merging branches",
                "yConfiguration Management: VCS (Version Control Systems):Tagging (labeling in TFS)",
                "yConfiguration Management: VCS (Version Control Systems):Creating and applying patches (shelvesets in TFS)",
                "yConfiguration Management: VCS (Version Control Systems):Revision specifiers",
                "yConfiguration Management: VCS (Version Control Systems):Data recovery",
                "yConfiguration Management: VCS (Version Control Systems):Using external editors and merge tools",
                "yConfiguration Management: VCS (Version Control Systems):Distributed VCS (if supported):Workflows",
                "yConfiguration Management: VCS (Version Control Systems):Distributed VCS (if supported):Checking out remote branches",
                "yConfiguration Management: VCS (Version Control Systems):Distributed VCS (if supported):Integrating contributed work",
                "kConstruction - Web UI:JavaScript: Variables",
                "kConstruction - Web UI:Javascript: Data types and types conversion",
                "kConstruction - Web UI:Javascript: Operators",
                "kConstruction - Web UI:Javascript: Control and Loop constructions",
                "kConstruction - Web UI:Javascript: Functions and Variables scopes",
                "kConstruction - Web UI:Javascript: Arrays",
                "kConstruction - Web UI:Javascript: Event Handling",
                "kConstruction - Web UI:DOM: Locating and modifying elements",
                "kConstruction - Web UI:HTML: Basic elements",
                "kConstruction - Web UI:CSS: Simple Style rules",
                "lConstruction - Web server applications - Java:Controlling the Structure of Generated Servlets: The JSP page Directive",
                "lConstruction - Web server applications - Java:Including Files and Applets in JSP Pages",
                "lConstruction - Web server applications - Java:Using JavaBeans Components in JSP Documents",
                "lConstruction - Web server applications - Java:The JSP 2.0 Expression Language",
                "lConstruction - Web server applications - Java:JSP Standard Tag Library (JSTL)",
                "lConstruction - Web server applications - Java:Using and Deploying Web Applications",
                "lConstruction - Web server applications - Java:Controlling Web Application Behavior with web.xml",
                "lConstruction - Web server applications - Java:Servlet and JSP Filters",
                "lConstruction - Web server applications - Java:The Application Events Framework",
                "lConstruction - Web server applications - Java:Tag Libraries: The Basics",
                "mConstruction - Java Enterprise Essentials:JEE platform components",
                "mConstruction - Java Enterprise Essentials:Java Application Server (one of: Tomcat/JBoss/Glassfish/etc):start/stop AS",
                "mConstruction - Java Enterprise Essentials:Java Application Server (one of: Tomcat/JBoss/Glassfish/etc):Deploy/Undeploy application",
                "mConstruction - Java Enterprise Essentials:Java Application Server (one of: Tomcat/JBoss/Glassfish/etc):Monitor app state: console/logs",
                "mConstruction - Java Enterprise Essentials:Manifest file",
                "mConstruction - Java Enterprise Essentials:Deployment packaging (ear, war, jar)",
                "mConstruction - Java Enterprise Essentials:Dependency Injection (aka DI): injection points (Java EE/Spring)",
                "mConstruction - Java Enterprise Essentials:Bean validation: concept, buld-in constraints",
                "mConstruction - Java Enterprise Essentials:DI containers (Spring/Google Guice/EJB3): concepts",
                "mConstruction - Java Enterprise Essentials:EJB:EJB component types",
                "mConstruction - Java Enterprise Essentials:EJB:Container services",
                "mConstruction - Java Enterprise Essentials:Spring:Spring building blocks",
                "mConstruction - Java Enterprise Essentials:Spring:IoC and DI in Spring",
                "nConstruction - Spring MVC - Java:Mapping requests with @RequestMapping",
                "nConstruction - Spring MVC - Java:Binding request parameters to method parameters (@RequestParam)",
                "nConstruction - Spring MVC - Java:Mapping the request body (@RequestBody)",
                "nConstruction - Spring MVC - Java:Mapping the response body (@ResponseBody)",
                "nConstruction - Spring MVC - Java:Providing a link to data from the model with @ModelAttribute",
                "nConstruction - Spring MVC - Java:Store attributes in a session (@SessionAttributes)",
                "nConstruction - Spring MVC - Java:Working with cookie values (@CookieValue)",
                "nConstruction - Spring MVC - Java:Accessing request header attributes (@RequestHeader)",
                "nConstruction - Spring MVC - Java:Request interception",
                "nConstruction - Spring MVC - Java:Use Controllers as a REST provider",
                "nConstruction - Spring MVC - Java:Resolving views with the ViewResolver interface",
                "nConstruction - Spring MVC - Java:Chaining ViewResolvers",
                "nConstruction - Spring MVC - Java:Redirecting and forwarding to views",
                "nConstruction - Spring MVC - Java:Handling exceptions",
                "nConstruction - Spring MVC - Java:Configuring Spring MVC",
                "nConstruction - Spring MVC - Java:Spring's form tag library",
                "nConstruction - Spring MVC - Java:Testing Spring MVC Application",
                "oConstruction - JSF:Managed beans: scopes, configuration options",
                "oConstruction - JSF:Navigation",
                "oConstruction - JSF:Standart JSF tags (core, tags and attributes)",
                "oConstruction - JSF:Facelets",
                "oConstruction - JSF:Ajax requests",
                "oConstruction - JSF:Data Tables",
                "oConstruction - JSF:Event handling",
                "oConstruction - JSF:Internationalization and Localization",
                "oConstruction - JSF:Conversion and validation",
                "oConstruction - JSF:External services configuration",
                "oConstruction - JSF:Working with Files and Images",
                "oConstruction - JSF:Drag & Drop",
                "pConstruction - SOAP Web Services - Java:SOAP: definition",
                "pConstruction - SOAP Web Services - Java:Define Web Service operations, return types",
                "pConstruction - SOAP Web Services - Java:Define Service Endpoint",
                "pConstruction - SOAP Web Services - Java:Build simple service with JAX-WS",
                "pConstruction - SOAP Web Services - Java:WSDL essentials",
                "qConstruction - Rest Web Services - Java:REST: definition",
                "qConstruction - Rest Web Services - Java:REST principles:assign everything an id",
                "qConstruction - Rest Web Services - Java:REST principles:link things together",
                "qConstruction - Rest Web Services - Java:REST principles:use standard HTTP method",
                "qConstruction - Rest Web Services - Java:REST principles:allow multiple representation",
                "qConstruction - Rest Web Services - Java:REST principles:stateless comunication",
                "qConstruction - Rest Web Services - Java:Binding HTTP methods",
                "qConstruction - Rest Web Services - Java:Define the media types supported by request and response",
                "qConstruction - Rest Web Services - Java:Build simple service with JAX-RS"
        };

        /**
         * 2 - 3 years
         */
        public static String[] intermediateJavaWebDesktopAndroid = {
                "gJava:JavaBean definition",
                "gJava:Declare interfaces:Implicit modifiers of interface members",
                "gJava:Declaring enums",
                "gJava:Overriding/Overloading",
                "gJava:Constructors and Instantiation:Order of initialization/calling of fields and constructors",
                "gJava:Constructors and Instantiation:Constructor overloading",
                "gJava:Using Wrapper classes and boxing:Intention of wrapping objects",
                "gJava:Using Wrapper classes and boxing:Creation wrapping objects",
                "gJava:Using Wrapper classes and boxing:Autoboxing",
                "gJava:Handling exceptions:exception matching and declaration",
                "gJava:Passing variables into methods",
                "gJava:String, StringBuilder and StringBuffer",
                "gJava:Overriding hashCode and equals",
                "gJava:Collections:Collection",
                "gJava:Collections:List interface",
                "gJava:Collections:Set interface",
                "gJava:Collections:Map interface",
                "gJava:Using collections API:ArrayList",
                "gJava:Using collections API:HashMap",
                "gJava:Generic types:Generics and legacy code",
                "gJava:Generic types:Generics declarations",
                "gJava:Inner classes:coding a regular inner class",
                "gJava:Anonymous inner classes",
                "gJava:Static inner classes:Instantiation and using",
                "gJava:Static inner classes:access to outer class instance fields",
                "gJava:Garbage Collection:Definition of grabage collection and garbage collector",
                "wUnit testing:Purpose of unit tests",
                "wUnit testing:JUnit 4:Setup and tear down",
                "wUnit testing:JUnit 4:Exception handling",
                "wUnit testing:JUnit 4:Asserts",
                "dOOP && OOD:Separation of concerns",
                "aEngineering Management - Process Planning (SDLC):Software development process:Software development activities",
                "aEngineering Management - Process Planning (SDLC):Basics of SDLC models:Waterfall",
                "aEngineering Management - Process Planning (SDLC):Basics of SDLC models:Spiral",
                "aEngineering Management - Process Planning (SDLC):Basics of SDLC models:Incremental development",
                "aEngineering Management - Process Planning (SDLC):Basics of SDLC models:Agile development",
                "aEngineering Management - Process Planning (SDLC):Basics of SDLC models:Prototyping",
                "aEngineering Management - Process Planning (SDLC):Basics of SDLC models:Rapid Application Development",
                "aEngineering Management - Process Planning (SDLC):Basics of SDLC models:Lean software development",
                "aEngineering Management - Process Planning (SDLC):Scrum:Roles and responsibilities",
                "aEngineering Management - Process Planning (SDLC):Scrum:Artifacts",
                "aEngineering Management - Process Planning (SDLC):Scrum:Flow",
                "aEngineering Management - Process Planning (SDLC):Scrum:Ceremonies",
                "bEngineering Management - Estimation:Scope Concept",
                "bEngineering Management - Estimation:Estimates, Targets, and Commitments ",
                "bEngineering Management - Estimation:Overestimate vs Underestimate ",
                "bEngineering Management - Estimation:Decomposition and Recomposition ",
                "bEngineering Management - Estimation:Analogy-based estimations ",
                "bEngineering Management - Estimation:Story based estimations ",
                "cRequirements - Software Requirements:Requirement definition ",
                "cRequirements - Software Requirements:Levels of Requirements: Business, User, and Functional requirements Most common requirements risks Characteristics of Excellent Requirements Benefits from a High-Quality Requirements Process ",
                "cRequirements - Software Requirements:Root Causes of Project Success and Failure",
                "cRequirements - Software Requirements:Sources of Requirements ",
                "cRequirements - Software Requirements:Basic Requirements Elicitation Techniques:Brainstorming",
                "cRequirements - Software Requirements:Basic Requirements Elicitation Techniques:Interviews",
                "cRequirements - Software Requirements:Basic Requirements Elicitation Techniques:Survey/ Questionnaire",
                "cRequirements - Software Requirements:Basic Requirements Elicitation Techniques:Document Analysis",
                "cRequirements - Software Requirements:Requirements artifacts - SRS (according to IEEE Standard 830-1998)",
                "dDesign - OOD:GoF Design Patterns",
                "dDesign - OOD:Architectural Patterns: Layered Architecture",
                "dDesign - OOD:Architectural Patterns: MVC",
                "dDesign - OOD:Architectural Patterns: SOA and EDA",
                "dDesign - OOD:Architectural Patterns: IoC",
                "dDesign - OOD:SOLID principles",
                "dDesign - OOD:Anti-patterns",
                "eDesign - DB Design: Relational terminology: Entities",
                "eDesign - DB Design: Relational terminology: Attributes",
                "eDesign - DB Design: Relational terminology: Records (Tuples)",
                "eDesign - DB Design: Relationships (One-to-One, One-to-Many)",
                "eDesign - DB Design: Understanding ER notation",
                "eDesign - DB Design: Understanding normalization concept",
                "eDesign - DB Design: Data Integrity",
                "fDesign - Modeling:UML: Basic Diagram Types",
                "fDesign - Modeling:UML: Use Case Diagram (Essentials)",
                "fDesign - Modeling:UML: Class Diagram (Essentials)",
                "fDesign - Modeling:Entity Relationship Diagrams",
                "fDesign - Modeling:Data Flow Diagrams",
                "gConstruction - Language - Java:Using Wrapper Classes and Boxing",
                "gConstruction - Language - Java:Overloading",
                "gConstruction - Language - Java:Garbage Collection",
                "gConstruction - Language - Java:Working with the Assertion Mechanism",
                "gConstruction - Language - Java:File Navigation and I/O",
                "gConstruction - Language - Java:Dates, Numbers, and Currency",
                "gConstruction - Language - Java:Parsing,Tokenizing, and Formatting",
                "gConstruction - Language - Java:Overriding hashCode() and equals()",
                "gConstruction - Language - Java:Collections",
                "gConstruction - Language - Java:Using the Collections Framework",
                "gConstruction - Language - Java:Generic Types",
                "gConstruction - Language - Java:JAR Files",
                "gConstruction - Language - Java:Static Imports",
                "gConstruction - Language - Java:Serialization",
                "gConstruction - Language - Java:Inner Classes",
                "gConstruction - Language - Java:Method-Local Inner Classes",
                "gConstruction - Language - Java:Anonymous Inner Classes",
                "gConstruction - Language - Java:Static Nested Classes",
                "gConstruction - Language - Java:Reflection",
                "gConstruction - Language - Java:Annotations",
                "gConstruction - Language - Java:Java 7 features:Locating Files and Directories Using Paths",
                "gConstruction - Language - Java:Java 7 features:Obtaining and Managing Files and Directories",
                "gConstruction - Language - Java:Java 7 features:Working with Filesystems in Java 7",
                "gConstruction - Language - Java:Java 7 features:Stream IO in Java 7",
                "hConstruction - Refactoring:Refactoring Concept (what/when/why)",
                "hConstruction - Refactoring:Smells Catalog and possible re-factorings",
                "hConstruction - Refactoring:Moving Features Between Objects (basic):Move Method",
                "hConstruction - Refactoring:Moving Features Between Objects (basic):Move Field",
                "hConstruction - Refactoring:Organizing Data (basic):Encapsulate Field",
                "hConstruction - Refactoring:Organizing Data (basic):Encapsulate Collection",
                "hConstruction - Refactoring:Composing Methods (basic):Extract Method",
                "hConstruction - Refactoring:Composing Methods (basic):Inline Method",
                "hConstruction - Refactoring:Composing Methods (basic):Inline Temp",
                "hConstruction - Refactoring:Composing Methods (basic):Replace Temp with Query",
                "hConstruction - Refactoring:Composing Methods (basic):Split Temporary Variable",
                "hConstruction - Refactoring:Simplifying Conditional Expressions (basic):Decompose Conditional Expression",
                "hConstruction - Refactoring:Simplifying Conditional Expressions (basic):Consolidate Conditional Expression",
                "hConstruction - Refactoring:Simplifying Conditional Expressions (basic):Consolidate Duplicate Conditional Fragments",
                "hConstruction - Refactoring:Simplifying Conditional Expressions (basic):Remove Control Flag",
                "hConstruction - Refactoring:Simplifying Conditional Expressions (basic):Replace Conditional with Polymorphism",
                "iConstruction - Concurrency - Java:Defining, Instantiating, and Starting Threads",
                "iConstruction - Concurrency - Java:Thread States and Transitions",
                "iConstruction - Concurrency - Java:Thread Interaction",
                "iConstruction - Concurrency - Java:Synchronizing Code with synchronized keyword",
                "iConstruction - Concurrency - Java:The Volatile Keyword",
                "iConstruction - Concurrency - Java:Race conditions",
                "iConstruction - Concurrency - Java:Nested Locks in Java",
                "iConstruction - Concurrency - Java:Using wait(), notify(), and notifyAll() for synchronization",
                "iConstruction - Concurrency - Java:Using of conditional variables for synchronization",
                "jConstruction - Networking - Java:The Layers of a Network",
                "jConstruction - Networking - Java:Application Layer Protocols Basics",
                "jConstruction - Networking - Java:Understanding Networks - Layers and Protocols",
                "jConstruction - Networking - Java:IP, TCP, and UDP",
                "jConstruction - Networking - Java:The Client/Server Model",
                "jConstruction - Networking - Java:Internet Standards",
                "jConstruction - Networking - Java:HTML, SGML, and XML",
                "jConstruction - Networking - Java:HTTP",
                "jConstruction - Networking - Java:MIME Media Types",
                "jConstruction - Networking - Java:Looking Up Internet Addresses",
                "jConstruction - Networking - Java:URLs and URIs",
                "jConstruction - Networking - Java:Sockets for Clients",
                "jConstruction - Networking - Java:Sockets for Servers",
                "jConstruction - Networking - Java:UDP Datagrams and Sockets",
                "jConstruction - Networking - Java:URLConnections",
                "rConstruction - Desktop applications - Java:Using Other Swing Features (actions, timers, and the system tray, etc.)",
                "rConstruction - Desktop applications - Java:Modifying the Look and Feel",
                "rConstruction - Desktop applications - Java:Drag and Drop and Data Transfer",
                "rConstruction - Desktop applications - Java:Performing Custom Painting",
                "rConstruction - Desktop applications - Java:Overview of the Java 2D API Concepts",
                "rConstruction - Desktop applications - Java:Getting Started with Graphics Working with Geometry",
                "rConstruction - Desktop applications - Java:Working with Text APIs",
                "rConstruction - Desktop applications - Java:Working with Images",
                "rConstruction - Desktop applications - Java:Printing",
                "rConstruction - Desktop applications - Java:Advanced Topics in Java2D",
                "rdAndroid:User interface - Advanced:Adapters and Data Binding",
                "rdAndroid:User interface - Advanced:Styles and Themes",
                "rdAndroid:User interface - Advanced:Building Custom Components",
                "rdAndroid:User interface - Advanced:Widgets",
                "rdAndroid:User interface - Advanced:2D Graphics and Animation",
                "rdAndroid:User interface - Advanced:Handling multitouch and gestures (zoom, drag)",
                "rdAndroid:User interface - Advanced:Best Practices for UI Design and Performance",
                "rdAndroid:User interface - Advanced:Designing for multiple screens",
                "rdAndroid:Application Components - Advanced:Bound Services and AIDL",
                "rdAndroid:Application Components - Advanced:Content Providers - Advanced, URI Permissions",
                "rdAndroid:Persistence - Advanced:SQLite Database",
                "rdAndroid:Persistence - Advanced:Loader, LoaderManager",
                "rdAndroid:Persistence - Advanced:Data Backup",
                "rdAndroid:Location, Maps and Sensors:Location and Maps",
                "rdAndroid:Location, Maps and Sensors:Sensors - Basic",
                "rdAndroid:Multimedia:Audio and Video Playback",
                "rdAndroid:Multimedia:Audio Capture",
                "rdAndroid:Multimedia:Camera",
                "rdAndroid:Connectivity:Bluetooth",
                "rdAndroid:Connectivity:NFC",
                "rdAndroid:Connectivity:WiFi Direct",
                "rdAndroid:Connectivity:Google Cloud Messaging",
                "sConstruction - SQL:Creating, modifying, removing database objects",
                "sConstruction - SQL:Aggregations (ORDER BY, GROUP BY, HAVING, SUM, COUNT, AVG, etc)",
                "sConstruction - SQL:Combining the results of multiple queries (union, except, intersect, minus, subqueries)",
                "sConstruction - SQL:Sessions, transactions, locks",
                "sConstruction - SQL:Implementing stored procedures, user-defined functions, triggers",
                "sConstruction - SQL:Cursors",
                "tConstruction - DB Access - Java: Processing SQL Statements with JDBC:Establishing a Connection, Using Statements and Prepared Statements, Retrieving and Modifying Values from Result Sets, Using Transactions",
                "tConstruction - DB Access - Java: Understanding object/relational mapping concepts",
                "tConstruction - DB Access - Java: JPA: EntityManager, Persistence Context, Persistence Unit and EntityManagerFactory concepts",
                "tConstruction - DB Access - Java:JPA Object-Relational Mapping: Annotations for Object/Relational Mapping",
                "tConstruction - DB Access - Java:JPA Object-Relational Mapping: Mapping to a Table",
                "tConstruction - DB Access - Java:JPA Object-Relational Mapping: Mapping Simple Types",
                "tConstruction - DB Access - Java:JPA Object-Relational Mapping: Mapping the Primary Key",
                "tConstruction - DB Access - Java:JPA Object-Relational Mapping: Mapping Relationships (Unidirectional, Bidirectional, Many-to-One, One-to-One, Many-to-Many)",
                "tConstruction - DB Access - Java:JPA Object-Relational Mapping: Embedded Objects",
                "tConstruction - DB Access - Java:JPA Object-Relational Mapping: Collection Mapping",
                "tConstruction - DB Access - Java:Entity Operations basics: Entity Instance Creation",
                "tConstruction - DB Access - Java:Entity Operations basics: Persisting an Entity Instance",
                "tConstruction - DB Access - Java:Entity Operations basics: Entity removal",
                "uConstruction - Big Data:Understanding MapReduce jobs",
                "uConstruction - Big Data:Hadoop architectural components, Single- and multi-node configuration, Web-based monitor tools",
                "uConstruction - Big Data:Work with HDFS",
                "uConstruction - Big Data:Map and Reduce tasks",
                "uConstruction - Big Data:Input and Output",
                "uConstruction - Big Data:Basic programming for Hadoop (using standard text input/output classes)",
                "uConstruction - Big Data:Understand difference between different MapReduce types and formats.",
                "vVerification - Code Quality - Java:Automated coding standards enforcement (Check Style)",
                "vVerification - Code Quality - Java:Code Reviews and Toolset (Jupiter)",
                "vVerification - Code Quality - Java:Preemptive Error Detection (Find Bugs, PMD)",
                "wVerification - Automated Testing - Java:Organizing and building JUnit tests",
                "wVerification - Automated Testing - Java:Managing test suites",
                "wVerification - Automated Testing - Java:Working with test data",
                "wVerification - Automated Testing - Java:Running tests",
                "wVerification - Automated Testing - Java:Reporting tests results",
                "wVerification - Automated Testing - Java:Mocks/Stubs",
                "wVerification - Automated Testing - Java:Unit and integration tests",
                "xConfiguration Management - Builds:Scripting multiphase (build, testing, deployment, …) build process",
                "xConfiguration Management - Builds:Integrating building of product installer",
                "xConfiguration Management - Builds:Generating release notes and/or other release documentation",
                "xConfiguration Management - Builds:Development of scheduled builds (night builds)",
                "xConfiguration Management - Builds:Monitoring build process",
                "xConfiguration Management - Builds:Build status reporting (notification)",
                "xConfiguration Management - Builds:Integrating deployment stage, moving product to release area",
                "xConfiguration Management - Builds:Integrating with source control, versioning, tagging, building releases ",
                "yConfiguration Management: VCS (Version Control Systems):Importing sources into repository",
                "yConfiguration Management: VCS (Version Control Systems):Exporting sources from repository",
                "yConfiguration Management: VCS (Version Control Systems):Comparing repository revisions",
                "yConfiguration Management: VCS (Version Control Systems):Creating a branch",
                "yConfiguration Management: VCS (Version Control Systems):Working with branch",
                "yConfiguration Management: VCS (Version Control Systems):Traversing branches",
                "yConfiguration Management: VCS (Version Control Systems):Common branching patterns (rebasing in Git)",
                "yConfiguration Management: VCS (Version Control Systems):Merging branches",
                "yConfiguration Management: VCS (Version Control Systems):Tagging (labeling in TFS)",
                "yConfiguration Management: VCS (Version Control Systems):Creating and applying patches (shelvesets in TFS)",
                "yConfiguration Management: VCS (Version Control Systems):Revision specifiers",
                "yConfiguration Management: VCS (Version Control Systems):Data recovery",
                "yConfiguration Management: VCS (Version Control Systems):Using external editors and merge tools",
                "yConfiguration Management: VCS (Version Control Systems):Distributed VCS (if supported):Workflows",
                "yConfiguration Management: VCS (Version Control Systems):Distributed VCS (if supported):Checking out remote branches",
                "yConfiguration Management: VCS (Version Control Systems):Distributed VCS (if supported):Integrating contributed work",
                "kConstruction - Web UI:JavaScript: Variables",
                "kConstruction - Web UI:Javascript: Data types and types conversion",
                "kConstruction - Web UI:Javascript: Operators",
                "kConstruction - Web UI:Javascript: Control and Loop constructions",
                "kConstruction - Web UI:Javascript: Functions and Variables scopes",
                "kConstruction - Web UI:Javascript: Arrays",
                "kConstruction - Web UI:Javascript: Event Handling",
                "kConstruction - Web UI:DOM: Locating and modifying elements",
                "kConstruction - Web UI:HTML: Basic elements",
                "kConstruction - Web UI:CSS: Simple Style rules",
                "lConstruction - Web server applications - Java:Controlling the Structure of Generated Servlets: The JSP page Directive",
                "lConstruction - Web server applications - Java:Including Files and Applets in JSP Pages",
                "lConstruction - Web server applications - Java:Using JavaBeans Components in JSP Documents",
                "lConstruction - Web server applications - Java:The JSP 2.0 Expression Language",
                "lConstruction - Web server applications - Java:JSP Standard Tag Library (JSTL)",
                "lConstruction - Web server applications - Java:Using and Deploying Web Applications",
                "lConstruction - Web server applications - Java:Controlling Web Application Behavior with web.xml",
                "lConstruction - Web server applications - Java:Servlet and JSP Filters",
                "lConstruction - Web server applications - Java:The Application Events Framework",
                "lConstruction - Web server applications - Java:Tag Libraries: The Basics",
                "mConstruction - Java Enterprise Essentials:JEE platform components",
                "mConstruction - Java Enterprise Essentials:Java Application Server (one of: Tomcat/JBoss/Glassfish/etc):start/stop AS",
                "mConstruction - Java Enterprise Essentials:Java Application Server (one of: Tomcat/JBoss/Glassfish/etc):Deploy/Undeploy application",
                "mConstruction - Java Enterprise Essentials:Java Application Server (one of: Tomcat/JBoss/Glassfish/etc):Monitor app state: console/logs",
                "mConstruction - Java Enterprise Essentials:Manifest file",
                "mConstruction - Java Enterprise Essentials:Deployment packaging (ear, war, jar)",
                "mConstruction - Java Enterprise Essentials:Dependency Injection (aka DI): injection points (Java EE/Spring)",
                "mConstruction - Java Enterprise Essentials:Bean validation: concept, buld-in constraints",
                "mConstruction - Java Enterprise Essentials:DI containers (Spring/Google Guice/EJB3): concepts",
                "mConstruction - Java Enterprise Essentials:EJB:EJB component types",
                "mConstruction - Java Enterprise Essentials:EJB:Container services",
                "mConstruction - Java Enterprise Essentials:Spring:Spring building blocks",
                "mConstruction - Java Enterprise Essentials:Spring:IoC and DI in Spring",
                "nConstruction - Spring MVC - Java:Mapping requests with @RequestMapping",
                "nConstruction - Spring MVC - Java:Binding request parameters to method parameters (@RequestParam)",
                "nConstruction - Spring MVC - Java:Mapping the request body (@RequestBody)",
                "nConstruction - Spring MVC - Java:Mapping the response body (@ResponseBody)",
                "nConstruction - Spring MVC - Java:Providing a link to data from the model with @ModelAttribute",
                "nConstruction - Spring MVC - Java:Store attributes in a session (@SessionAttributes)",
                "nConstruction - Spring MVC - Java:Working with cookie values (@CookieValue)",
                "nConstruction - Spring MVC - Java:Accessing request header attributes (@RequestHeader)",
                "nConstruction - Spring MVC - Java:Request interception",
                "nConstruction - Spring MVC - Java:Use Controllers as a REST provider",
                "nConstruction - Spring MVC - Java:Resolving views with the ViewResolver interface",
                "nConstruction - Spring MVC - Java:Chaining ViewResolvers",
                "nConstruction - Spring MVC - Java:Redirecting and forwarding to views",
                "nConstruction - Spring MVC - Java:Handling exceptions",
                "nConstruction - Spring MVC - Java:Configuring Spring MVC",
                "nConstruction - Spring MVC - Java:Spring's form tag library",
                "nConstruction - Spring MVC - Java:Testing Spring MVC Application",
                "oConstruction - JSF:Managed beans: scopes, configuration options",
                "oConstruction - JSF:Navigation",
                "oConstruction - JSF:Standart JSF tags (core, tags and attributes)",
                "oConstruction - JSF:Facelets",
                "oConstruction - JSF:Ajax requests",
                "oConstruction - JSF:Data Tables",
                "oConstruction - JSF:Event handling",
                "oConstruction - JSF:Internationalization and Localization",
                "oConstruction - JSF:Conversion and validation",
                "oConstruction - JSF:External services configuration",
                "oConstruction - JSF:Working with Files and Images",
                "oConstruction - JSF:Drag & Drop",
                "pConstruction - SOAP Web Services - Java:SOAP: definition",
                "pConstruction - SOAP Web Services - Java:Define Web Service operations, return types",
                "pConstruction - SOAP Web Services - Java:Define Service Endpoint",
                "pConstruction - SOAP Web Services - Java:Build simple service with JAX-WS",
                "pConstruction - SOAP Web Services - Java:WSDL essentials",
                "qConstruction - Rest Web Services - Java:REST: definition",
                "qConstruction - Rest Web Services - Java:REST principles:assign everything an id",
                "qConstruction - Rest Web Services - Java:REST principles:link things together",
                "qConstruction - Rest Web Services - Java:REST principles:use standard HTTP method",
                "qConstruction - Rest Web Services - Java:REST principles:allow multiple representation",
                "qConstruction - Rest Web Services - Java:REST principles:stateless comunication",
                "qConstruction - Rest Web Services - Java:Binding HTTP methods",
                "qConstruction - Rest Web Services - Java:Define the media types supported by request and response",
                "qConstruction - Rest Web Services - Java:Build simple service with JAX-RS"
        };

        /**
         * 3 - 4 years
         */
        public static String[] seniorJavaWebDesktop = {
                "hJava:Garbage Collection:finalize",
                "hJava:Serialization",
                "hJava:Dates, Numbers and Currency",
                "hJava:String Formatting",
                "hJava:Collections:Collections and Arrays",
                "hJava:Using collections API:LinkedList",
                "hJava:Generic types:Polymorphism and generics",
                "hJava:Generic types:Generics methods",
                "hJava:Inner classes:reference outer instance from within inner class",
                "hJava:Method local inner classes:local method variables in inner classes",
                "Spring:Bean Overview:Naming beans",
                "Spring:Dependencies:Dependency injection(setter , constructor and so on)",
                "Spring:Dependencies and configuration in detail:Straight values",
                "Spring:Dependencies and configuration in detail:Refrences to another beans",
                "Spring:Dependencies and configuration in detail:Inner beans",
                "Spring:Dependencies and configuration in detail:Collections",
                "Spring:Dependencies and configuration in detail:Lazy initialized beans",
                "Spring:Dependencies and configuration in detail:Method injection",
                "Spring:Bean scopes:singleton",
                "Spring:Bean scopes:prototype",
                "Spring:Bean scopes:request",
                "Spring:Bean scopes:session",
                "Spring:Bean scopes:scoped beans (session, request, prototype) as dependencies",
                "Spring:Annotation based configuration:Required",
                "Spring:Annotation based configuration:Autowired",
                "Spring:Class path scanning and managed components:Component and other stereotype annotations",
                "Spring:Class path scanning and managed components:Naming auto detected components",
                "Spring:Class path scanning and managed components:Providing scope for auto detected components",
                "Spring:Spring 3 field formatting:Annotation Driven Formatting",
                "Spring:Spring 3 Validation:Configuring bean validation implementation",
                "Spring:Spring 3 Validation:Spring MVC 3 Validation",
                "Spring:Integration testing:Context management and caching",
                "Spring:Integration testing:Dependency injection of text fixtures",
                "Spring:Integration testing:Transaction managament",
                "Spring:Integration testing:JUnit support",
                "Spring:Declarative transaction managament:Understending Spring declarative implementation model",
                "Spring:Declarative transaction managament:Rolling back declarative transaction",
                "Spring:Declarative transaction managament:@Transactional and its settings",
                "Spring:Declarative transaction managament:Transaction propagation levels",
                "Spring:JPA DAO support:LocalContainerEntityManagerFactoryBean",
                "Spring:JPA DAO support:Transaction Managament",
                "Spring:Web MVC Framework:DispatcherServlet and request lifecycle",
                "Spring:Web MVC Framework:mvc:annotation-driven",
                "Spring:Web MVC Framework:Defining controller with @Controller",
                "Spring:Web MVC Framework:Mapping requests with @RequestsMapping",
                "Spring:Web MVC Framework:Parameters and returns of @RequestMapping methods",
                "Spring:Web MVC Framework:URI templates",
                "Spring:Web MVC Framework:@RequestBody",
                "Spring:Web MVC Framework:@ResponseBody",
                "Spring:Web MVC Framework:@ModelAttribute",
                "Spring:Web MVC Framework:@SessionAttributes",
                "Spring:Web MVC Framework:@RequestHeader",
                "Spring:Web MVC Framework:@CookieValue",
                "Spring:Resolving views:ViewResolver",
                "Spring:Resolving views:redirect:",
                "Spring:Resolving views:forward:",
                "Spring:Spring multipart support",
                "Spring:Handling exceptions:@ExceptionHandler",
                "Spring:REST:General principles",
                "Spring:REST:RestTemplate",
                "Spring:REST:HttpMessage conversion",
                "Spring:REST:Spring MVC support",
                "Unit Testing:Difference between unit and integration tests (pros and cons)",
                "Unit Testing:TDD concepts:Development style",
                "Unit Testing:TDD concepts:Benefits",
                "Unit Testing:Mocks concept",
                "Unit Testing:JUnit 4:Timeout",
                "Unit Testing:JUnit 4:Ignore",
                "SVN:Advanced concepts:tag",
                "SVN:Advanced concepts:branch",
                "SVN:Advanced commands:merge",
                "SVN:Advanced commands:patch",
                "dOOP && OOD:Purpose of OOP",
                "dOOP && OOD:Coupling and Cohesion",
                "dOOP && OOD:Information expert (GRASP)",
                "dOOP && OOD:Interface segregation principle",
                "dOOP && OOD:Single responsibility principle",
                "dOOP && OOD:Examples of usage interfaces and abstract classes",
                "dOOP && OOD:Dependency Inversion",
                "dOOP && OOD:Open/Closed Principle",
                "dOOP && OOD:Composite Reuse",
                "dOOP && OOD:Acyclic Dependencies Principle",
                "dOOP && OOD:Immutability",
                "dOOP && OOD:GOF Patterns:Why we need patterns",
                "dOOP && OOD:GOF Patterns:At least three from each category",
                "dOOP && OOD:GOF Patterns:Examples from JDK (at least 3)",
                "JPA:ORM definition and purpose",
                "JPA:OR mapping:Entity definition",
                "JPA:OR mapping:Access entity state",
                "JPA:OR mapping:Mapping to table",
                "JPA:OR mapping:Mapping simple types",
                "JPA:OR mapping:Column mapping",
                "JPA:OR mapping:Enumerations",
                "JPA:OR mapping:Temporal types",
                "JPA:OR mapping:Id generation",
                "JPA:OR mapping:Relationship types",
                "JPA:OR mapping:One to many - primary key mappings",
                "JPA:OR mapping:Supported collection types",
                "JPA:OR mapping:OrderBy for List",
                "JPA:OR mapping:MapKey for Map",
                "JPA:OR mapping:Lazy loading",
                "JPA:Entity Manager:persist",
                "JPA:Entity Manager:find",
                "JPA:Entity Manager:remove",
                "JPA:Entity Manager:cascading options",
                "JPA:Entity Manager:detachment and merge",
                "JPA:JPQL:select",
                "JPA:JPQL:filtering results",
                "JPA:JPQL:projections",
                "JPA:JPQL:aggregate queries",
                "JPA:JPQL:query parameters",
                "JPA:JPQL:dynamic query definition",
                "JPA:JPQL:named query",
                "JPA:JPQL:query paging",
                "JPA:Locking:Optimistic locking",
                "Maven:Default configuration:Directory layout",
                "Maven:Default configuration:One primary output per project",
                "Maven:Plugins:Knowledge of what plug-ins there are",
                "Maven:Plugins:Configuring a plugin",
                "Maven:Plugins:Binding plugin goals to lifecycle phases",
                "Maven:Repositories:Local and remote repos",
                "Maven:Repositories:SNAPSHOTs vs regular versions",
                "Maven:Dependency managament:Transitive dependencies",
                "Maven:Dependency managament:How to exclude unwanted transitive dependencies",
                "Maven:Dependency managament:Different scopes and when to use them",
                "Maven:Dependency managament:Using dependencyManagement to share dependencies",
                "Maven:Build Lifecycle:different phases",
                "SQL:Table structure:schema",
                "SQL:Table structure:table",
                "SQL:Table structure:row",
                "SQL:Table structure:column",
                "SQL:Table structure:primary key",
                "SQL:Table structure:foreign key",
                "SQL:SQL select:like, in, between",
                "SQL:SQL select:aggregate queries",
                "SQL:SQL select:order by",
                "SQL:SQL select:distinct or count(distinct)",
                "SQL:SQL select:joins",
                "SQL:SQL select:difference between where and having",
                "SQL:SQL insert/update/delete",
                "SQL:Nulls",
                "aEngineering Management - Process Planning (SDLC):Software Development Methodologies:Abiliton SDLC",
                "aEngineering Management - Process Planning (SDLC):Software Development Methodologies:Agile:Scrum:Planning",
                "aEngineering Management - Process Planning (SDLC):Software Development Methodologies:Agile:Scrum:Reporting",
                "aEngineering Management - Process Planning (SDLC):Software Development Methodologies:Agile:Scrum:Scaling projects",
                "aEngineering Management - Process Planning (SDLC):Software Development Methodologies:Agile:Agile Unified Process",
                "aEngineering Management - Process Planning (SDLC):Software Development Methodologies:Agile:Extreme Programming (XP):Concepts",
                "aEngineering Management - Process Planning (SDLC):Software Development Methodologies:Agile:Extreme Programming (XP):Practices",
                "aEngineering Management - Process Planning (SDLC):Software Development Methodologies:Agile:Extreme Programming (XP):Planning",
                "aEngineering Management - Process Planning (SDLC):Software Development Methodologies:Agile:Extreme Programming (XP):Testing",
                "aEngineering Management - Process Planning (SDLC):Software Development Methodologies:Agile:Extreme Programming (XP):Test-driven development",
                "aEngineering Management - Process Planning (SDLC):Software Development Methodologies:Agile:Feature Driven Development",
                "aEngineering Management - Process Planning (SDLC):Software Development Methodologies:Rational Unified Process (RUP):Key features and best practices",
                "aEngineering Management - Process Planning (SDLC):Software Development Methodologies:Rational Unified Process (RUP):Static structure",
                "aEngineering Management - Process Planning (SDLC):Software Development Methodologies:Rational Unified Process (RUP):Dynamic structure",
                "aEngineering Management - Process Planning (SDLC):Software Development Methodologies:Rational Unified Process (RUP):Use-Case-Driven process",
                "aEngineering Management - Process Planning (SDLC):Software Development Methodologies:Lean software development:Kanban",
                "aEngineering Management - Process Planning (SDLC):Engineering Process Planning:Evaluating technical feasibility",
                "aEngineering Management - Process Planning (SDLC):Engineering Process Planning:Defining unit-testing process",
                "aEngineering Management - Process Planning (SDLC):Engineering Process Planning:Defining code review process",
                "bEngineering Management - Estimation:Cone of Uncertainty ",
                "bEngineering Management - Estimation:Source of Estimation Errors ",
                "bEngineering Management - Estimation:Diseconomies of Scale ",
                "bEngineering Management - Estimation:Count, Compute, Judge techniques ",
                "bEngineering Management - Estimation:Delphi method",
                "bEngineering Management - Estimation:Challenges with Estimating Size ",
                "bEngineering Management - Estimation:Challenges with Estimating Effort ",
                "bEngineering Management - Estimation:Challenges with Estimating Schedule ",
                "bEngineering Management - Estimation:Story based scope definition: scoping project, release planning  ",
                "bEngineering Management - Estimation:Documenting and presenting estimation results ",
                "bEngineering Management - Estimation:PERT analysis ",
                "cRequirements - Software Requirements:System requirements",
                "cRequirements - Software Requirements:Non-functional requirements",
                "cRequirements - Software Requirements:Product champion ",
                "cRequirements - Software Requirements:User classes and their characteristics ",
                "cRequirements - Software Requirements:Software Quality Attributes ",
                "cRequirements - Software Requirements:Assumptions, constraints and their roles ",
                "cRequirements - Software Requirements:Requirements Elicitation Techniques:Focus Groups",
                "cRequirements - Software Requirements:Requirements Elicitation Techniques:Interface Analysis",
                "cRequirements - Software Requirements:Requirements Elicitation Techniques:Observation",
                "cRequirements - Software Requirements:Requirements Elicitation Techniques:Requirements Workshops",
                "cRequirements - Software Requirements:Requirements Elicitation Techniques:Prototyping",
                "cRequirements - Software Requirements:Basic Modeling techniques:Data dictionary and glossary",
                "cRequirements - Software Requirements:Basic Modeling techniques:Data flow diagrams",
                "cRequirements - Software Requirements:Basic Modeling techniques:ERD",
                "cRequirements - Software Requirements:Basic Modeling techniques:Process modeling (flowcharts, activity diagrams)",
                "cRequirements - Software Requirements:Requirements artifacts:Product Vision and Scope document etc",
                "dDesign - OOD:GoF Design Patterns",
                "dDesign - OOD:Architectural Patterns: Layered Architecture",
                "dDesign - OOD:Architectural Patterns: MVC",
                "dDesign - OOD:Architectural Patterns: SOA and EDA",
                "dDesign - OOD:Architectural Patterns: IoC",
                "dDesign - OOD:SOLID principles",
                "dDesign - OOD:Anti-patterns",
                "eDesign - DB Design:Understanding RDBMS architecture",
                "eDesign - DB Design:Transactions: ACID",
                "eDesign - DB Design:Transactions: Recovery",
                "eDesign - DB Design:Transactions: Locking",
                "eDesign - DB Design:Transactions: Isolation",
                "eDesign - DB Design:Transactions: Concurrency",
                "eDesign - DB Design:Optimization database (performance, volume) ",
                "eDesign - DB Design:Optimizing the Database Design by Denormalizing",
                "fDesign - Modeling:UML: Structure Diagrams",
                "fDesign - Modeling:Class Diagram (Advanced)",
                "fDesign - Modeling:Component Diagram",
                "fDesign - Modeling:Composite Structures Diagram",
                "fDesign - Modeling:package my.Diagram",
                "fDesign - Modeling:Deployment Diagram",
                "fDesign - Modeling:Object Diagram",
                "fDesign - Modeling:UML: Behavior Diagrams",
                "fDesign - Modeling:Activity Diagram",
                "fDesign - Modeling:Use Case Diagram (Advanced)",
                "fDesign - Modeling:State Diagram",
                "fDesign - Modeling:UML: Interaction Diagrams",
                "fDesign - Modeling:Sequence Diagram",
                "fDesign - Modeling:Communication Diagram",
                "gSecurity - Java:Java SE Cryptography Architecture (JCA)",
                "gSecurity - Java:Java Authentication and Authorization Service (JAAS)",
                "gSecurity - Java:Java EE: Securing Applications (Enterprise, Web)",
                "gSecurity - Java:Java EE: Programmatic and declarative security",
                "gSecurity - Java:Java EE: Securing HTTP resources",
                "gSecurity - Java:Spring Security: project modules",
                "gSecurity - Java:Spring Security: Authentication Mechanisms (Basic, Digest, Remember-Me, Anonymous, OpenID, LDAP Authentication, OAuth 2.0)",
                "gSecurity - Java:Spring Security: Authorization Architecture",
                "gSecurity - Java:Spring Security: Domain Object Security (ACLs)",
                "gSecurity - Java:OWASP Top 10 Security risks",
                "gSecurity - Java:Writing firewall-friendly applications",
                "gSecurity - Java:Protecting against canonical representation attacks",
                "gSecurity - Java:Protecting against SQL-injection attacks",
                "gSecurity - Java:Protecting against cross-site scripting attack",
                "gSecurity - Java:Protecting against DoS attacks",
                "gSecurity - Java:RSA (algorithm)",
                "hConstruction - Language - Java:Using Wrapper Classes and Boxing",
                "hConstruction - Language - Java:Overloading",
                "hConstruction - Language - Java:Garbage Collection",
                "hConstruction - Language - Java:Working with the Assertion Mechanism",
                "hConstruction - Language - Java:File Navigation and I/O",
                "hConstruction - Language - Java:Dates, Numbers, and Currency",
                "hConstruction - Language - Java:Parsing,Tokenizing, and Formatting",
                "hConstruction - Language - Java:Overriding hashCode() and equals()",
                "hConstruction - Language - Java:Collections",
                "hConstruction - Language - Java:Using the Collections Framework",
                "hConstruction - Language - Java:Generic Types",
                "hConstruction - Language - Java:JAR Files",
                "hConstruction - Language - Java:Static Imports",
                "hConstruction - Language - Java:Serialization",
                "hConstruction - Language - Java:Inner Classes",
                "hConstruction - Language - Java:Method-Local Inner Classes",
                "hConstruction - Language - Java:Anonymous Inner Classes",
                "hConstruction - Language - Java:Static Nested Classes",
                "hConstruction - Language - Java:Reflection",
                "hConstruction - Language - Java:Annotations",
                "iConstruction - Language - Java:Java 7 features:Locating Files and Directories Using Paths",
                "iConstruction - Language - Java:Java 7 features:Obtaining and Managing Files and Directories",
                "iConstruction - Language - Java:Java 7 features:Working with Filesystems in Java 7",
                "iConstruction - Language - Java:Java 7 features:Stream IO in Java 7",
                "jConstruction - Refactoring:Making Method Calls Simpler",
                "jConstruction - Refactoring:Dealing with Generalization",
                "jConstruction - Refactoring:Creation:Replace Constructors with Creation Methods",
                "jConstruction - Refactoring:Creation:Move Creation Knowledge to Factory",
                "jConstruction - Refactoring:Creation:Encapsulate Classes with Factory",
                "jConstruction - Refactoring:Creation:Encapsulate Composite with Builder",
                "jConstruction - Refactoring:Simplification:Replace Conditional Logic with Strategy",
                "jConstruction - Refactoring:Simplification:Replace State-Altering Conditionals with State",
                "jConstruction - Refactoring:Simplification:Replace Implicit Tree with Composite",
                "jConstruction - Refactoring:Simplification:Replace Conditional Dispatcher with Command",
                "jConstruction - Refactoring:Generalization:Form Template Method",
                "jConstruction - Refactoring:Generalization:Extract Composite",
                "jConstruction - Refactoring:Generalization:Replace Hard-Coded Notifications with Observer",
                "jConstruction - Refactoring:Generalization:Red green refactoring",
                "kConstruction - Concurrency - Java:Atomic Classes",
                "kConstruction - Concurrency - Java:Usage of ThreadLocal and InheritableThreadLocal  variables",
                "kConstruction - Concurrency - Java:Synchronizing a block of code with a Lock:The Lock Interface",
                "kConstruction - Concurrency - Java:Synchronizing a block of code with a Lock:Synchronizing data access with read/write locks",
                "kConstruction - Concurrency - Java:Deadlock vs Livelock",
                "kConstruction - Concurrency - Java:Preventing and detection of deadlocks",
                "kConstruction - Concurrency - Java:Lock Starvation",
                "kConstruction - Concurrency - Java:Advanced Synchronization Techniques:Synchronization Terms",
                "kConstruction - Concurrency - Java:Advanced Synchronization Techniques:Control the access to one or more shared resources with Semaphore",
                "kConstruction - Concurrency - Java:Advanced Synchronization Techniques:Allows a thread to wait for the finalization of multiple operations with CountDownLatch",
                "kConstruction - Concurrency - Java:Advanced Synchronization Techniques:The synchronization of multiple threads in a common point with CyclicBarrier",
                "kConstruction - Concurrency - Java:Advanced Synchronization Techniques:Interchange date between two threads with Exchanger",
                "kConstruction - Concurrency - Java:Advanced Synchronization Techniques:Control the execution of concurrent tasks divided in phases with Phaser",
                "kConstruction - Concurrency - Java:Threads and Collection Classes from java.util.concurrent package:Thread-Notification Collection Classes",
                "kConstruction - Concurrency - Java:Threads and Collection Classes from java.util.concurrent package:Threadsafe Collection Classes: ConcurrentHashMap, CopyOnWriteArrayList, ConcurrentLinkedQueue",
                "kConstruction - Concurrency - Java:Threads and Collection Classes from java.util.concurrent package:static methods of the Collections class for synchronized collections creation",
                "kConstruction - Concurrency - Java:Working with Thread Priorities",
                "kConstruction - Concurrency - Java:Organize Thread Pooling with Executors and ExecutorService",
                "kConstruction - Concurrency - Java:Fork/Join Framework",
                "kConstruction - Concurrency - Java:Daemon Threads",
                "Construction - Distributed Objects and Components - Java:Anatomy of a Distributed Application",
                "Construction - Distributed Objects and Components - Java:Requirements for Developing Distributed Application",
                "Construction - Distributed Objects and Components - Java:Distributed Objects In Java",
                "Construction - Networking - Java:The Layers of a Network",
                "Construction - Networking - Java:Application Layer Protocols Basics",
                "Construction - Networking - Java:Understanding Networks - Layers and Protocols",
                "Construction - Networking - Java:IP, TCP, and UDP",
                "Construction - Networking - Java:The Client/Server Model",
                "Construction - Networking - Java:Internet Standards",
                "Construction - Networking - Java:HTML, SGML, and XML",
                "Construction - Networking - Java:HTTP",
                "Construction - Networking - Java:MIME Media Types",
                "Construction - Networking - Java:Looking Up Internet Addresses",
                "Construction - Networking - Java:URLs and URIs",
                "Construction - Networking - Java:Sockets for Clients",
                "Construction - Networking - Java:Sockets for Servers",
                "Construction - Networking - Java:UDP Datagrams and Sockets",
                "Construction - Networking - Java:URLConnections",
                "Construction - Desktop applications - Java:Using Other Swing Features (actions, timers, and the system tray, etc.)",
                "Construction - Desktop applications - Java:Modifying the Look and Feel",
                "Construction - Desktop applications - Java:Drag and Drop and Data Transfer",
                "Construction - Desktop applications - Java:Performing Custom Painting",
                "Construction - Desktop applications - Java:Overview of the Java 2D API Concepts",
                "Construction - Desktop applications - Java:Getting Started with Graphics Working with Geometry",
                "Construction - Desktop applications - Java:Working with Text APIs",
                "Construction - Desktop applications - Java:Working with Images",
                "Construction - Desktop applications - Java:Printing",
                "Construction - Desktop applications - Java:Advanced Topics in Java2D",
                "Construction - SQL:Creating, modifying, removing database objects",
                "Construction - SQL:Aggregations (ORDER BY, GROUP BY, HAVING, SUM, COUNT, AVG, etc)",
                "Construction - SQL:Combining the results of multiple queries (union, except, intersect, minus, subqueries)",
                "Construction - SQL:Sessions, transactions, locks",
                "Construction - SQL:Implementing stored procedures, user-defined functions, triggers",
                "Construction - SQL:Cursors",
                "Construction - DB Access - Java:JPA: Work with Entity Manager:Entity operation revised",
                "Construction - DB Access - Java:JPA: Work with Entity Manager:Container-Managed Entity Managers",
                "Construction - DB Access - Java:JPA: Work with Entity Manager:Synchronization to the Database",
                "Construction - DB Access - Java:JPA: Work with Entity Manager:Application-Managed Entity Managers",
                "Construction - DB Access - Java:JPA: Work with Entity Manager:Obtaining an Entity Manager in the Java EE Environment",
                "Construction - DB Access - Java:JPA: Work with Entity Manager:Obtaining an Application-managed Entity Manager",
                "Construction - DB Access - Java:JPA: Work with Entity Manager:Obtaining an Entity Manager Factory in a Java SE/EE Container",
                "Construction - DB Access - Java:Transaction Management:Container-managed and Bean-managed transactions",
                "Construction - DB Access - Java:Transaction Management:JTA Transaction Management",
                "Construction - DB Access - Java:Transaction Management:Extended Persistence Contexts",
                "Construction - DB Access - Java:Transaction Management:Transaction-Scoped Persistence Contexts",
                "Construction - DB Access - Java:Transaction Management:Application-Managed Persistence Contexts",
                "Construction - DB Access - Java:Transaction Management:Persistence Context Lifetime",
                "Construction - DB Access - Java:Transaction Management:Clearing the Persistence Context",
                "Construction - DB Access - Java:Transaction Management:Resource-Local Transactions",
                "Construction - DB Access - Java:Transaction Management:Transaction Rollback and Entity State",
                "Construction - DB Access - Java:Detachment and Merging:Detached Entities",
                "Construction - DB Access - Java:Detachment and Merging:Detached Entities and Lazy Loading",
                "Construction - DB Access - Java:Detachment and Merging:Merging strategies",
                "Construction - DB Access - Java:Detachment and Merging:Avoiding detachment",
                "Construction - DB Access - Java:Java Persistence Query Language:Select Queries",
                "Construction - DB Access - Java:Java Persistence Query Language:Aggregate Queries",
                "Construction - DB Access - Java:Java Persistence Query Language:Update Queries",
                "Construction - DB Access - Java:Java Persistence Query Language:Delete Queries",
                "Construction - DB Access - Java:Java Persistence Query Language:Named and Dynamic Query",
                "Construction - DB Access - Java:Constructing Criteria API Queries:CriteriaQuery Creation",
                "Construction - DB Access - Java:Constructing Criteria API Queries:Subqueries",
                "Construction - DB Access - Java:Constructing Criteria API Queries:GroupBy and Having",
                "Construction - DB Access - Java:Constructing Criteria API Queries:Ordering the Query Results",
                "Construction - DB Access - Java:Constructing Criteria API Queries:Restricting the Query Result",
                "Construction - DB Access - Java:Constructing Criteria API Queries:Constructing Strongly-typed Queries using the javax.persistence.metamodel Interfaces",
                "Construction - DB Access - Java:Inheritance in JPA:Abstract Entity Classes",
                "Construction - DB Access - Java:Inheritance in JPA:Mapped Superclasses",
                "Construction - DB Access - Java:Inheritance in JPA:Inheritance Mapping Strategies",
                "Construction - DB Access - Java:Compound Primary Keys",
                "Construction - DB Access - Java:Defining and Executing SQL Queries",
                "Construction - DB Access - Java:SQL Query Result Set Mappings",
                "Construction - DB Access - Java:Locking in JPA:Optimistic Locking",
                "Construction - DB Access - Java:Locking in JPA:Version Attributes",
                "Construction - DB Access - Java:Locking in JPA:Pessimistic Locking",
                "Construction - DB Access - Java:Locking in JPA:Lock Modes: OPTIMISTIC, OPTIMISTIC_FORCE_INCREMENT, PESSIMISTIC_READ, PESSIMISTIC_WRITE, PESSIMISTIC_FORCE_INCREMENT",
                "Construction - DB Access - Java:Locking in JPA:Lock Mode Properties and Uses",
                "Construction - DB Access - Java:Locking in JPA:OptimisticLockException",
                "Construction - DB Access - Java:JPA and Validation ",
                "Construction - DB Access - Java:Caching in JPA",
                "Construction - DB Access - Java:Object-Relational Mapping via XML file (aka orm.xml)",
                "Construction - DB Access - Java:Configuring Persistence Unit",
                "Construction - DB Access - Java:Schema generation with JPA",
                "Construction - DB Access - Java:Hibernate:Transactions and concurrency control",
                "Construction - DB Access - Java:Hibernate:Caching in Hibernate",
                "Construction - Big Data:Understanding MapReduce jobs",
                "Construction - Big Data:Hadoop architectural components, Single- and multi-node configuration, Web-based monitor tools",
                "Construction - Big Data:Work with HDFS",
                "Construction - Big Data:Map and Reduce tasks",
                "Construction - Big Data:Input and Output",
                "Construction - Big Data:Basic programming for Hadoop (using standard text input/output classes)",
                "Construction - Big Data:Understand difference between different MapReduce types and formats.",
                "Construction - Big Data:Reading and writing to HDFS programmatically",
                "Construction - Big Data:Advanced programming for Hadoop (writing custom InputFormat, RecordReader, InputSplit)",
                "Construction - Big Data:Using combiner functions.",
                "Construction - Big Data:Hadoop I/O",
                "Construction - Big Data:Managing Hadoop",
                "Construction - Big Data:Running Hadoop in the Cloud",
                "Verification - Code Quality - Java:Automated coding standards enforcement (Check Style)",
                "Verification - Code Quality - Java:Code Reviews and Toolset (Jupiter)",
                "Verification - Code Quality - Java:Preemptive Error Detection (Find Bugs, PMD)",
                "Verification - Automated Testing - Java:Organizing and building JUnit tests",
                "Verification - Automated Testing - Java:Managing test suites",
                "Verification - Automated Testing - Java:Working with test data",
                "Verification - Automated Testing - Java:Running tests",
                "Verification - Automated Testing - Java:Reporting tests results",
                "Verification - Automated Testing - Java:Mocks/Stubs",
                "Verification - Automated Testing - Java:Unit and integration tests",
                "Configuration Management - Builds:Scripting multiphase (build, testing, deployment, …) build process",
                "Configuration Management - Builds:Integrating building of product installer",
                "Configuration Management - Builds:Generating release notes and/or other release documentation",
                "Configuration Management - Builds:Development of scheduled builds (night builds)",
                "Configuration Management - Builds:Monitoring build process",
                "Configuration Management - Builds:Build status reporting (notification)",
                "Configuration Management - Builds:Integrating deployment stage, moving product to release area",
                "Configuration Management - Builds:Integrating with source control, versioning, tagging, building releases ",
                "Configuration Management - Builds:Continuous integration concept, best practices and framework",
                "Configuration Management: VCS (Version Control Systems):Importing sources into repository",
                "Configuration Management: VCS (Version Control Systems):Exporting sources from repository",
                "Configuration Management: VCS (Version Control Systems):Comparing repository revisions",
                "Configuration Management: VCS (Version Control Systems):Creating a branch",
                "Configuration Management: VCS (Version Control Systems):Working with branch",
                "Configuration Management: VCS (Version Control Systems):Traversing branches",
                "Configuration Management: VCS (Version Control Systems):Common branching patterns (rebasing in Git)",
                "Configuration Management: VCS (Version Control Systems):Merging branches",
                "Configuration Management: VCS (Version Control Systems):Tagging (labeling in TFS)",
                "Configuration Management: VCS (Version Control Systems):Creating and applying patches (shelvesets in TFS)",
                "Configuration Management: VCS (Version Control Systems):Revision specifiers",
                "Configuration Management: VCS (Version Control Systems):Data recovery",
                "Configuration Management: VCS (Version Control Systems):Using external editors and merge tools",
                "Configuration Management: VCS (Version Control Systems):Distributed VCS (if supported):Workflows",
                "Configuration Management: VCS (Version Control Systems):Distributed VCS (if supported):Checking out remote branches",
                "Configuration Management: VCS (Version Control Systems):Distributed VCS (if supported):Integrating contributed work",
                "Construction - Web UI:Javascript: Event Understanding ( propagation, attach/detach)",
                "Construction - Web UI:HTML: Page Layouts with tables",
                "Construction - Web UI:HTML: Page Layouts with divs",
                "Construction - Web UI:HTML: Frames",
                "Construction - Web UI:HTML: Embedded multimedia",
                "Construction - Web UI:CSS: Elements positioning and layering",
                "Construction - Web UI:CSS: Tables properties",
                "Construction - Web UI:CSS: Complex rules and defining styles structure",
                "Construction - Web UI:XML: XmlDocument",
                "Construction - Web UI:XML: XmlHttpRequest",
                "Construction - Web UI:AJAX: Consuming Webservices",
                "Construction - Web UI:AJAX: Understanding JSON",
                "Construction - Web UI:Web Browser: Cookies management",
                "Construction - Web UI:Javascript: Closures",
                "Construction - Web UI:Javascript: Objects",
                "Construction - Web server applications - Java:Controlling the Structure of Generated Servlets: The JSP page Directive",
                "Construction - Web server applications - Java:Including Files and Applets in JSP Pages",
                "Construction - Web server applications - Java:Using JavaBeans Components in JSP Documents",
                "Construction - Web server applications - Java:The JSP 2.0 Expression Language",
                "Construction - Web server applications - Java:JSP Standard Tag Library (JSTL)",
                "Construction - Web server applications - Java:Using and Deploying Web Applications",
                "Construction - Web server applications - Java:Controlling Web Application Behavior with web.xml",
                "Construction - Web server applications - Java:Servlet and JSP Filters",
                "Construction - Web server applications - Java:The Application Events Framework",
                "Construction - Web server applications - Java:Tag Libraries: The Basics",
                "Construction - Java Enterprise Essentials:DI: Interceptors and Decorators",
                "Construction - Java Enterprise Essentials:DI: Scopes and Contexts",
                "Construction - Java Enterprise Essentials:DI: Producer, Disposer, Stereotypes, Events",
                "Construction - Java Enterprise Essentials:Bean validtion: create custom validation",
                "Construction - Java Enterprise Essentials:Bean validation: organize validation in Validation Groups",
                "Construction - Java Enterprise Essentials:Bean validation: integration with JPA",
                "Construction - Java Enterprise Essentials:Deployment descriptor: Web Fragments",
                "Construction - Java Enterprise Essentials:DI containers (Spring/Google Guice/EJB3): configuration",
                "Construction - Java Enterprise Essentials:Spring:Lazy-initialized beans",
                "Construction - Java Enterprise Essentials:Spring:Autowiring",
                "Construction - Java Enterprise Essentials:Spring:Constructor, Method injection",
                "Construction - Java Enterprise Essentials:Spring:Bean scopes",
                "Construction - Java Enterprise Essentials:Spring:Lifecycle callbacks",
                "Construction - Java Enterprise Essentials:Spring:ApplicationContextAware and BeanNameAware",
                "Construction - Java Enterprise Essentials:Spring:Spring Container Extension Points: BeanPostProcessor, BeanFactoryPostProcessor",
                "Construction - Java Enterprise Essentials:Spring:Annotation-based container configuration",
                "Construction - Java Enterprise Essentials:Spring:Java-based container configuration",
                "Construction - Java Enterprise Essentials:Spring:Classpath scanning and managed components",
                "Construction - Java Enterprise Essentials:Spring:Spring and JSR 330 Standard Annotations",
                "Construction - Java Enterprise Essentials:Spring:Type conversion in Spring",
                "Construction - Java Enterprise Essentials:Spring:Spring and Validation",
                "Construction - Java Enterprise Essentials:EJB3:Stateless Session Bean: SessionContext, EJBContext, Lifecycle",
                "Construction - Java Enterprise Essentials:EJB3:Stateful Session Bean",
                "Construction - Java Enterprise Essentials:EJB3:Singleton Session Bean",
                "Construction - Java Enterprise Essentials:EJB3:Message-Driven Beans",
                "Construction - Java Enterprise Essentials:EJB3:Managing transactions with EJB",
                "Construction - Java Enterprise Essentials:EJB3:Accessing resources using DI and JNDI",
                "Construction - Java Enterprise Essentials:EJB3:Packaging EJB 3 applications",
                "Construction - Java Enterprise Essentials:EJB3:New features of EJB 3.2",
                "Construction - Spring MVC - Java:Mapping requests with @RequestMapping",
                "Construction - Spring MVC - Java:Binding request parameters to method parameters (@RequestParam)",
                "Construction - Spring MVC - Java:Mapping the request body (@RequestBody)",
                "Construction - Spring MVC - Java:Mapping the response body (@ResponseBody)",
                "Construction - Spring MVC - Java:Providing a link to data from the model with @ModelAttribute",
                "Construction - Spring MVC - Java:Store attributes in a session (@SessionAttributes)",
                "Construction - Spring MVC - Java:Working with cookie values (@CookieValue)",
                "Construction - Spring MVC - Java:Accessing request header attributes (@RequestHeader)",
                "Construction - Spring MVC - Java:Request interception",
                "Construction - Spring MVC - Java:Use Controllers as a REST provider",
                "Construction - Spring MVC - Java:Resolving views with the ViewResolver interface",
                "Construction - Spring MVC - Java:Chaining ViewResolvers",
                "Construction - Spring MVC - Java:Redirecting and forwarding to views",
                "Construction - Spring MVC - Java:Handling exceptions",
                "Construction - Spring MVC - Java:Configuring Spring MVC",
                "Construction - Spring MVC - Java:Spring's form tag library",
                "Construction - Spring MVC - Java:Testing Spring MVC Application",
                "Construction - JSF:Managed beans: scopes, configuration options",
                "Construction - JSF:Navigation",
                "Construction - JSF:Standart JSF tags (core, tags and attributes)",
                "Construction - JSF:Facelets",
                "Construction - JSF:Ajax requests",
                "Construction - JSF:Data Tables",
                "Construction - JSF:Event handling",
                "Construction - JSF:Internationalization and Localization",
                "Construction - JSF:Conversion and validation",
                "Construction - JSF:External services configuration",
                "Construction - JSF:Working with Files and Images",
                "Construction - JSF:Drag & Drop",
                "Construction - SOAP Web Services - Java:SOAP: definition",
                "Construction - SOAP Web Services - Java:Define Web Service operations, return types",
                "Construction - SOAP Web Services - Java:Define Service Endpoint",
                "Construction - SOAP Web Services - Java:Build simple service with JAX-WS",
                "Construction - SOAP Web Services - Java:WSDL essentials",
                "Construction - Rest Web Services - Java:Model the URIs",
                "Construction - Rest Web Services - Java:Subresource Locators",
                "Construction - Rest Web Services - Java:JAX-RS Injection:@PathParam",
                "Construction - Rest Web Services - Java:JAX-RS Injection:@QueryParam",
                "Construction - Rest Web Services - Java:JAX-RS Injection:@CookieParam",
                "Construction - Rest Web Services - Java:JAX-RS Injection:@MatrixParam",
                "Construction - Rest Web Services - Java:JAX-RS Injection:@Context",
                "Construction - Rest Web Services - Java:JAX-RS Injection:@HeaderParam",
                "Construction - Rest Web Services - Java:JAX-RS Content Handlers:JAXB",
                "Construction - Rest Web Services - Java:JAX-RS Content Handlers:JSON",
                "Construction - Rest Web Services - Java:JAX-RS Content Handlers:Configure custom content marshalling (atom, rss)",
                "Construction - Rest Web Services - Java:Return result: Default Response Codes",
                "Construction - Rest Web Services - Java:Handling exceptions",
                "Construction - Rest Web Services - Java:HTTP content negotiation",
                "Construction - Rest Web Services - Java:HATEOAS principle",
                "Construction - Rest Web Services - Java:Configuration and Deployment (one of REST frameworks): CXF/Jersey/RESTeasy/Restlet/Spring MVC",
                "Construction - Rest Web Services - Java:New features of JAX-RS 2.0:invoke REST service with Client API",
                "Construction - Rest Web Services - Java:New features of JAX-RS 2.0:Create custom filters",
                "Construction - Rest Web Services - Java:New features of JAX-RS 2.0:Create custom interceptors: motivation, order of execution",
                "Construction - Rest Web Services - Java:New features of JAX-RS 2.0:Server-side Asynchronous HTTP"
        };



    }

}